@stardustlc/dsh-dream 0.3.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 stardustlc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.en.md

@@ -0,0 +1,56 @@
+[简体中文](README.md)
+
+# dsh-dream
+
+> **An agent that dreams**: session replay (dream material) → reflection (interpretation) → dream journal (memory consolidation).
+
+Humans consolidate memories by replaying the day during sleep — dsh-dream gives DeepSeek Harness agents the same ability. It reads your historical sessions (the official multi-frame zstd session logs, parsed with zero dependencies), distills dream material, lets the agent reflect, and writes permanent dream journal entries that can be recalled later.
+
+## Compatibility
+
+Verified against `@deepseek-ai/dsh@0.1.2-alpha.2` (2026-08-31). Follows the cordis patch-bundle model (`cordis.patch.yml` + `dsh.bundle.patch`); no runtime imports of `@deepseek-ai/*` internals. Session reading is layout-blind with respect to the official JSONL-zstd multi-frame format and packed-chunk rows.
+
+## Install / Uninstall
+
+```bash
+dsh plugin --profile web add @stardustlc/dsh-dream
+# or from source:
+dsh plugin --profile web add github:STARDUSTLC666/dsh-dream
+dsh plugin --profile web remove @stardustlc/dsh-dream
+```
+
+Restart the web service afterwards. The dream journal lives at `~/.dsh/.dsh-dream/dreams.jsonl` and survives uninstallation; remove that directory manually for a full cleanup. Part of [dsh-suite](https://github.com/STARDUSTLC666/dsh-suite) — one command installs all 18 STARDUSTLC plugins.
+
+## Tools
+
+| Tool | Purpose | Key params |
+| :-- | :-- | :-- |
+| `dream_digest` | Replay recent sessions (title/turns/user quotes/assistant conclusions/tool footprint); subagent sessions skipped; official packed-chunk rows decoded | `maxSessions`; `mode`: full/brief |
+| `dream_save` | Write a reflection + 1-5 lessons + mood to the permanent journal | `reflection` required |
+| `dream_journal` | List dreams, newest first | `limit` |
+| `dream_recall` | Keyword search across the journal | `query` required |
+| `dream_bridge` | Merge top lessons into AGENTS.md (idempotent marker block) — dreams become long-term memory | `path` required |
+| `dream_health` | Self-check: sessions dir / dream count / config summary | — |
+
+`dream_bridge` merges the most frequent dream lessons into a target `AGENTS.md` behind idempotent marker blocks; `dream_journal` also reports mood distribution and top lessons.
+
+The bundled `dream-protocol` skill teaches the agent when and how to dream (and the journaling discipline: patterns only, never secrets).
+
+## Privacy (on by default)
+
+Dream material is masked before journaling: sk keys, GitHub/Groq/Slack tokens, AWS keys, JWTs, `password/token/api_key` assignments and long high-entropy strings become `[masked·type]`. Disable with `maskSecrets: false`.
+
+## Permissions & data
+
+Read-only access to the sessions directory; appends JSONL to the journal directory; no network calls. Session content may be sensitive — the protocol forbids secrets in dreams, but the journal is plaintext: review before sharing.
+
+## Development
+
+```bash
+pnpm install
+pnpm test   # build + 48 tests (multi-frame zstd fixtures, packed-chunk decoding, privacy masking, journal round-trip, bridge idempotency, stats, six tools, registration lifecycle)
+```
+
+## License
+
+MIT (see [LICENSE](LICENSE))

package/README.md

@@ -0,0 +1,103 @@
+[English](README.en.md)
+
+# dsh-dream
+
+> **会做梦的 agent**：会话回放（梦原料）→ 反思（解梦）→ 梦境日记（记忆巩固）。
+
+![license](https://img.shields.io/github/license/STARDUSTLC666/dsh-dream) ![stars](https://img.shields.io/github/stars/STARDUSTLC666/dsh-dream?style=social)
+
+人睡觉时大脑回放白天的经历、巩固记忆——dsh-dream 让 DeepSeek Harness 的 agent 也拥有这个能力：读取你的历史会话（官方多帧 zstd 会话日志，零依赖解析），提炼梦原料，反思后写入永久梦境日记，下次醒来可以忆梦。
+
+## 兼容性
+
+在 `@deepseek-ai/dsh@0.1.2-alpha.2` 上验证（2026-08-31）。遵循 cordis 组合包补丁模型（`cordis.patch.yml` + `dsh.bundle.patch`），运行时不 import 任何 `@deepseek-ai/*` 内部模块。会话读取兼容官方 JSONL-zstd 多帧格式与 packed-chunk 行（只取所需事件类型，布局无关）。
+
+## 安装
+
+```bash
+dsh plugin --profile web add @stardustlc/dsh-dream
+# 或从源码：
+dsh plugin --profile web add github:STARDUSTLC666/dsh-dream
+```
+
+安装后重启 Web 服务即可。本插件收录于 [dsh-suite](https://github.com/STARDUSTLC666/dsh-suite) 全家桶——一条命令可装入 STARDUSTLC 全部 18 个插件。
+
+## 卸载
+
+```bash
+dsh plugin --profile web remove @stardustlc/dsh-dream
+```
+
+卸载后重启 Web 服务。梦境日记默认保存在 `~/.dsh/.dsh-dream/dreams.jsonl`，卸载不会删除；如需彻底清理请手动删除该目录。
+
+## 工具一览
+
+| 工具 | 作用 | 关键参数 |
+| :-- | :-- | :-- |
+| `dream_digest` | 入梦：回放最近会话（标题/轮数/用户原话/助手结论/工具足迹），自动跳过子代理，还原官方打包行流式文本 | `maxSessions` 可选；`mode`: full/brief |
+| `dream_save` | 记梦：反思 + 1-5 条教训 + 心境，永久保存 | `reflection` 必填；`lessons`/`mood` 可选 |
+| `dream_journal` | 翻梦：倒序列出历史梦境 | `limit` 可选 |
+| `dream_recall` | 忆梦：关键词检索梦境 | `query` 必填 |
+| `dream_bridge` | 渡梦：把高频教训幂等合并进 AGENTS.md，梦变成长期记忆 | `path` 必填；`maxLessons` 可选 |
+| `dream_health` | 自检：会话目录/梦境计数/配置汇总 | 无 |
+
+### 示例
+
+```text
+dream_digest { maxSessions: 5, mode: 'brief' }
+dream_save { reflection: "用户反复遇到输入法问题，偏好先自查再重启", lessons: ["先问是否重启过应用"], mood: "平静" }
+dream_recall { query: "输入法" }
+dream_bridge { path: "AGENTS.md", maxLessons: 10 }
+```
+
+## 渡梦：让梦变成长期记忆
+
+`dream_bridge` 把梦境日记里出现频次最高的教训合并进目标 `AGENTS.md`：带 `<!-- dsh-dream:lessons:start/end -->` 标记块，重复执行只刷新块内内容（幂等），反复梦到的教训会标注次数。`dream_journal` 同时给出心境分布与最常梦到的教训统计。
+
+## 做梦协议（随包技能）
+
+插件附带 `dream-protocol` 技能，教 agent 何时做梦（开场/收尾/距上次做梦超一天）、做梦三步（入梦→解梦→记梦）与记梦纪律（只沉淀规律不复述流水账、密钥隐私不入梦、存疑要标注）。
+
+## 配置
+
+在你自己的 profile 的 `cordis.patch.yml` 里覆盖本插件行（缺省时用默认值也能加载）：
+
+```yaml
+- id: dream
+  name: '@stardustlc/dsh-dream'
+  config:
+    # sessionsRoot: ''        # 会话根目录（默认 ~/.dsh/sessions）
+    # journalDir: ''          # 梦境日记目录（默认 ~/.dsh/.dsh-dream）
+    maxSessions: 10           # dream_digest 最多回放会话数（1-50）
+    maxCharsPerSession: 6000  # 每会话摘要字符上限（500-50000）
+    # maxUserMessages: 5      # 每会话保留用户消息条数（1-20）
+    # maskSecrets: true       # 梦原料隐私脱敏开关（默认开）
+```
+
+## 隐私保护（默认开启）
+
+梦原料入梦前自动脱敏：sk 密钥、GitHub/Groq/Slack 令牌、AWS 密钥、JWT、`password/token/api_key` 赋值、超长高熵串都会被打成 `[已脱敏·类型]`。不需要时可在配置里设 `maskSecrets: false`。
+
+## 权限与数据
+
+- 只读访问会话目录（`~/.dsh/sessions`），不修改任何会话文件；
+- 梦境日记以 JSONL 追加写入 `journalDir`；
+- 不发起任何网络请求；
+- 会话内容可能包含敏感信息——做梦协议明确禁止把密钥/隐私写入梦境，但梦境日记本身是明文存储，请自行评估。
+
+## 排错
+
+- `dream_digest` 返回 0 个会话：先运行 `dream_health` 检查会话目录是否存在；确认 DSH 已产生过会话；
+- 梦境写不进去：检查 `journalDir` 可写权限；
+- 加载失败：查看 DSH 启动日志中带 `[dsh-dream]` 前缀的告警。
+
+## 开发
+
+```bash
+pnpm install
+pnpm test       # 构建 + 48 个测试（多帧 zstd 夹具、打包行解码、隐私脱敏、梦境日记往返、记忆桥接幂等、统计、六工具、注册生命周期）
+```
+
+## License
+
+MIT（见 [LICENSE](LICENSE)）

package/cordis.patch.yml

@@ -0,0 +1,8 @@
+# dsh-dream 组合包补丁：把做梦插件行插入 profile。
+# 用户可在自己 profile 的 cordis.patch.yml 里按 id 覆盖 config（见 README 配置示例）。
+- insert:
+    - id: dream
+      name: '@stardustlc/dsh-dream'
+      config:
+        maxSessions: 10
+        maxCharsPerSession: 6000

package/lib/bridge.d.ts

@@ -0,0 +1,15 @@
+export declare const BRIDGE_START = "<!-- dsh-dream:lessons:start\uFF08\u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u5DE5\u7F16\u8F91\u5757\u5185\u5185\u5BB9\uFF09 -->";
+export declare const BRIDGE_END = "<!-- dsh-dream:lessons:end -->";
+/** 生成教训块文本。 */
+export declare function buildLessonsBlock(lessons: Array<{
+    lesson: string;
+    count: number;
+}>): string;
+/**
+ * 把梦境教训合并进目标文件：无文件则创建，有标记块则替换，无标记块则追加。
+ * @returns 动作类型与写入的教训数。
+ */
+export declare function bridgeDreams(journalDir: string, targetPath: string, maxLessons: number): {
+    action: 'created' | 'replaced' | 'appended';
+    lessonsCount: number;
+};

package/lib/bridge.js

@@ -0,0 +1,46 @@
+/**
+ * 记忆桥接：把梦境里的高频教训合并进 AGENTS.md（幂等，带标记块）。
+ *
+ * @module dsh-dream/bridge
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { dreamStats } from './journal.js';
+export const BRIDGE_START = '<!-- dsh-dream:lessons:start（自动生成，请勿手工编辑块内内容） -->';
+export const BRIDGE_END = '<!-- dsh-dream:lessons:end -->';
+/** 生成教训块文本。 */
+export function buildLessonsBlock(lessons) {
+    const lines = [BRIDGE_START, '', '## 梦境沉淀（dsh-dream 自动生成）', ''];
+    for (const item of lessons) {
+        lines.push('- ' + item.lesson + (item.count > 1 ? '（反复梦到 ' + item.count + ' 次）' : ''));
+    }
+    lines.push('', BRIDGE_END);
+    return lines.join('\n');
+}
+/**
+ * 把梦境教训合并进目标文件：无文件则创建，有标记块则替换，无标记块则追加。
+ * @returns 动作类型与写入的教训数。
+ */
+export function bridgeDreams(journalDir, targetPath, maxLessons) {
+    const stats = dreamStats(journalDir);
+    if (stats.total === 0) {
+        throw new Error('还没有做过梦：请先用 dream_digest + dream_save 做梦，再来桥接记忆。');
+    }
+    const lessons = stats.topLessons.slice(0, maxLessons);
+    const block = buildLessonsBlock(lessons);
+    if (!existsSync(targetPath)) {
+        mkdirSync(dirname(targetPath), { recursive: true });
+        writeFileSync(targetPath, block + '\n', 'utf8');
+        return { action: 'created', lessonsCount: lessons.length };
+    }
+    const current = readFileSync(targetPath, 'utf8');
+    const startIdx = current.indexOf(BRIDGE_START);
+    const endIdx = current.indexOf(BRIDGE_END);
+    if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+        const next = current.slice(0, startIdx) + block + current.slice(endIdx + BRIDGE_END.length);
+        writeFileSync(targetPath, next, 'utf8');
+        return { action: 'replaced', lessonsCount: lessons.length };
+    }
+    writeFileSync(targetPath, current.replace(/\s*$/, '') + '\n\n' + block + '\n', 'utf8');
+    return { action: 'appended', lessonsCount: lessons.length };
+}

package/lib/config.d.ts

@@ -0,0 +1,17 @@
+/** 已解析配置。 */
+export interface ResolvedDreamConfig {
+    /** 会话根目录（默认 ~/.dsh/sessions）。 */
+    sessionsRoot: string;
+    /** 梦境日记目录（默认 ~/.dsh/.dsh-dream）。 */
+    journalDir: string;
+    /** dream_digest 最多回放的会话数（1-50，默认 10）。 */
+    maxSessions: number;
+    /** 每个会话摘要的最大字符数（500-50000，默认 6000）。 */
+    maxCharsPerSession: number;
+    /** 每个会话最多保留的用户消息条数（1-20，默认 5）。 */
+    maxUserMessages: number;
+    /** 梦原料入梦前是否做隐私脱敏（默认 true）。 */
+    maskSecrets: boolean;
+}
+/** 解析并校验插件配置。 */
+export declare function resolveConfig(raw?: Record<string, unknown> | null): ResolvedDreamConfig;

package/lib/config.js

@@ -0,0 +1,28 @@
+/**
+ * dsh-dream 配置解析：会话根目录、梦境日记目录与摘要上限。
+ *
+ * @module dsh-dream/config
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+function str(value, fallback) {
+    return typeof value === 'string' && value.trim() !== '' ? value.trim() : fallback;
+}
+function clamp(value, fallback, min, max) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return fallback;
+    return Math.min(max, Math.max(min, Math.round(value)));
+}
+/** 解析并校验插件配置。 */
+export function resolveConfig(raw) {
+    const cfg = raw ?? {};
+    const home = homedir();
+    return {
+        sessionsRoot: str(cfg.sessionsRoot, join(home, '.dsh', 'sessions')),
+        journalDir: str(cfg.journalDir, join(home, '.dsh', '.dsh-dream')),
+        maxSessions: clamp(cfg.maxSessions, 10, 1, 50),
+        maxCharsPerSession: clamp(cfg.maxCharsPerSession, 6000, 500, 50000),
+        maxUserMessages: clamp(cfg.maxUserMessages, 5, 1, 20),
+        maskSecrets: cfg.maskSecrets !== false,
+    };
+}

package/lib/index.d.ts

@@ -0,0 +1,33 @@
+import { type DreamToolDefinition } from './tools.js';
+/** cordis 服务注入：要用 ctx.tools 与 ctx.skills。 */
+export declare const name = "dream";
+export declare const inject: string[];
+/** 插件所需的最小 ctx 面。 */
+export interface DreamPluginContext {
+    tools: {
+        register(definition: DreamToolDefinition): () => void;
+    };
+    skills?: {
+        register(definition: {
+            name: string;
+            description: string;
+            content: string;
+            resourceBase: {
+                kind: 'directory';
+                path: string;
+            };
+            source?: string;
+        }): () => void;
+    };
+    on?(event: string, listener: () => void): () => void;
+}
+/** 随包技能目录。 */
+export declare function bundledSkillsDir(): string;
+/** 插件入口。 */
+export declare function apply(ctx: DreamPluginContext, config?: Record<string, unknown> | null): void;
+export * from './config.js';
+export * from './sessions.js';
+export * from './journal.js';
+export * from './tools.js';
+export * from './mask.js';
+export * from './bridge.js';

package/lib/index.js

@@ -0,0 +1,68 @@
+/**
+ * dsh-dream —— 做梦插件：会话回放（梦原料）→ 反思 → 梦境日记（记忆巩固）。
+ *
+ * @module dsh-dream
+ */
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { join } from 'node:path';
+import { resolveConfig } from './config.js';
+import { buildDreamTools } from './tools.js';
+/** cordis 服务注入：要用 ctx.tools 与 ctx.skills。 */
+export const name = 'dream';
+export const inject = ['tools', 'skills'];
+/** 随包技能目录。 */
+export function bundledSkillsDir() {
+    return fileURLToPath(new URL('../skills/', import.meta.url));
+}
+/** 插件入口。 */
+export function apply(ctx, config) {
+    let cfg;
+    try {
+        cfg = resolveConfig(config);
+    }
+    catch (error) {
+        console.warn('[dsh-dream] ' + (error instanceof Error ? error.message : String(error)));
+        cfg = resolveConfig(null);
+    }
+    const disposers = [];
+    for (const definition of buildDreamTools(cfg)) {
+        disposers.push(ctx.tools.register(definition));
+    }
+    // 注册做梦协议技能（文件缺失只告警，不阻断）
+    if (typeof ctx.skills?.register === 'function') {
+        try {
+            const dir = join(bundledSkillsDir(), 'dream-protocol');
+            const text = readFileSync(join(dir, 'SKILL.md'), 'utf8');
+            const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text);
+            let description = '做梦协议：会话回放、反思与梦境日记。';
+            if (match !== null) {
+                const descMatch = /description:\s*(.+)/.exec(match[1]);
+                if (descMatch !== null)
+                    description = descMatch[1].trim();
+            }
+            disposers.push(ctx.skills.register({
+                name: 'dream-protocol',
+                description,
+                content: match !== null ? text.slice(match[0].length).trimStart() : text,
+                resourceBase: { kind: 'directory', path: dir },
+                source: 'runtime',
+            }));
+        }
+        catch (error) {
+            console.warn('[dsh-dream] 做梦协议技能加载失败：' + (error instanceof Error ? error.message : String(error)));
+        }
+    }
+    if (typeof ctx.on === 'function') {
+        ctx.on('dispose', () => {
+            for (const dispose of disposers)
+                dispose();
+        });
+    }
+}
+export * from './config.js';
+export * from './sessions.js';
+export * from './journal.js';
+export * from './tools.js';
+export * from './mask.js';
+export * from './bridge.js';

package/lib/journal.d.ts

@@ -0,0 +1,26 @@
+/** 一条梦境。 */
+export interface DreamEntry {
+    id: string;
+    at: string;
+    reflection: string;
+    lessons: string[];
+    mood: string;
+}
+export declare function journalFile(journalDir: string): string;
+/** 追加一条梦；返回落盘后的条目。 */
+export declare function saveDream(journalDir: string, reflection: string, lessons: string[], mood: string): DreamEntry;
+/** 倒序读取梦境（新梦在前）；损坏行跳过。 */
+export declare function readDreams(journalDir: string, limit: number): DreamEntry[];
+/** 梦境统计：总数、心境分布、高频教训。 */
+export interface DreamStats {
+    total: number;
+    moods: Record<string, number>;
+    topLessons: Array<{
+        lesson: string;
+        count: number;
+    }>;
+}
+/** 统计梦境（基于全量日记）。 */
+export declare function dreamStats(journalDir: string): DreamStats;
+/** 关键词检索梦境（不区分大小写，命中 reflection/lessons）。 */
+export declare function searchDreams(journalDir: string, query: string, limit: number): DreamEntry[];

package/lib/journal.js

@@ -0,0 +1,80 @@
+/**
+ * 梦境日记：JSONL 追加式存储（每行一条梦），倒序读取与关键词检索。
+ *
+ * @module dsh-dream/journal
+ */
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export function journalFile(journalDir) {
+    return join(journalDir, 'dreams.jsonl');
+}
+/** 追加一条梦；返回落盘后的条目。 */
+export function saveDream(journalDir, reflection, lessons, mood) {
+    const trimmed = reflection.trim();
+    if (trimmed === '')
+        throw new Error('梦境不能为空：请在 reflection 里写下你的反思。');
+    const entry = {
+        id: 'dream-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 8),
+        at: new Date().toISOString(),
+        reflection: trimmed,
+        lessons: lessons.map((lesson) => lesson.trim()).filter((lesson) => lesson !== ''),
+        mood: mood.trim() || '平静',
+    };
+    mkdirSync(journalDir, { recursive: true });
+    appendFileSync(journalFile(journalDir), JSON.stringify(entry) + '\n', 'utf8');
+    return entry;
+}
+/** 倒序读取梦境（新梦在前）；损坏行跳过。 */
+export function readDreams(journalDir, limit) {
+    const file = journalFile(journalDir);
+    if (!existsSync(file))
+        return [];
+    const lines = readFileSync(file, 'utf8').split('\n').filter((line) => line.trim() !== '');
+    const out = [];
+    for (const line of lines) {
+        try {
+            const rec = JSON.parse(line);
+            if (typeof rec.reflection === 'string') {
+                out.push({
+                    id: String(rec.id ?? ''),
+                    at: String(rec.at ?? ''),
+                    reflection: rec.reflection,
+                    lessons: Array.isArray(rec.lessons) ? rec.lessons.filter((l) => typeof l === 'string') : [],
+                    mood: typeof rec.mood === 'string' ? rec.mood : '',
+                });
+            }
+        }
+        catch { /* 损坏行跳过 */ }
+    }
+    return out.reverse().slice(0, limit);
+}
+/** 统计梦境（基于全量日记）。 */
+export function dreamStats(journalDir) {
+    const dreams = readDreams(journalDir, 100000);
+    const moods = {};
+    const lessonCount = new Map();
+    for (const dream of dreams) {
+        const mood = dream.mood !== '' ? dream.mood : '平静';
+        moods[mood] = (moods[mood] ?? 0) + 1;
+        for (const lesson of dream.lessons) {
+            const key = lesson.toLowerCase();
+            lessonCount.set(key, (lessonCount.get(key) ?? 0) + 1);
+        }
+    }
+    const topLessons = [...lessonCount.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10)
+        .map(([key, count]) => {
+        const original = dreams.flatMap((d) => d.lessons).find((l) => l.toLowerCase() === key) ?? key;
+        return { lesson: original, count };
+    });
+    return { total: dreams.length, moods, topLessons };
+}
+/** 关键词检索梦境（不区分大小写，命中 reflection/lessons）。 */
+export function searchDreams(journalDir, query, limit) {
+    const needle = query.toLowerCase();
+    return readDreams(journalDir, 1000).filter((entry) => {
+        const haystack = (entry.reflection + ' ' + entry.lessons.join(' ')).toLowerCase();
+        return haystack.includes(needle);
+    }).slice(0, limit);
+}

package/lib/mask.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 隐私脱敏：梦原料入梦前对密钥/令牌/凭据打码。
+ * 只处理明显模式与超长高熵串，宁可漏报不误伤正常文本。
+ *
+ * @module dsh-dream/mask
+ */
+/** 已知密钥/令牌模式。 */
+export declare const SECRET_PATTERNS: Array<{
+    re: RegExp;
+    label: string;
+}>;
+/** 对文本做脱敏；无命中时原样返回。 */
+export declare function maskSecrets(text: string): string;

package/lib/mask.js

@@ -0,0 +1,33 @@
+/**
+ * 隐私脱敏：梦原料入梦前对密钥/令牌/凭据打码。
+ * 只处理明显模式与超长高熵串，宁可漏报不误伤正常文本。
+ *
+ * @module dsh-dream/mask
+ */
+/** 已知密钥/令牌模式。 */
+export const SECRET_PATTERNS = [
+    { re: /sk-[A-Za-z0-9_-]{16,}/g, label: '疑似 sk 密钥' },
+    { re: /(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{16,}/g, label: '疑似 GitHub 令牌' },
+    { re: /github_pat_[A-Za-z0-9_]{16,}/g, label: '疑似 GitHub 细粒度令牌' },
+    { re: /gsk_[A-Za-z0-9]{16,}/g, label: '疑似 Groq 密钥' },
+    { re: /xox[baprs]-[A-Za-z0-9-]{10,}/g, label: '疑似 Slack 令牌' },
+    { re: /AKIA[0-9A-Z]{16}/g, label: '疑似 AWS 访问密钥' },
+    { re: /eyJ[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{10,}/g, label: '疑似 JWT' },
+];
+/** 凭据赋值模式：password/secret/token/apikey = 值。 */
+const CRED_ASSIGN = /(password|passwd|secret|token|api[_-]?key)(\s*[:=：]\s*)([^\s"',，。]{6,})/gi;
+/** 超长高熵串：40+ 位字母数字混合（含大小写或数字）。 */
+const LONG_TOKEN = /(?<![A-Za-z0-9])[A-Za-z0-9_\-+/=]{40,}(?![A-Za-z0-9])/g;
+function looksHighEntropy(text) {
+    return /[a-z]/.test(text) && (/[A-Z]/.test(text) || /[0-9]/.test(text));
+}
+/** 对文本做脱敏；无命中时原样返回。 */
+export function maskSecrets(text) {
+    let out = text;
+    for (const { re, label } of SECRET_PATTERNS) {
+        out = out.replace(re, '[已脱敏·' + label + ']');
+    }
+    out = out.replace(CRED_ASSIGN, (_m, key, sep) => key + sep + '[已脱敏·凭据]');
+    out = out.replace(LONG_TOKEN, (m) => (looksHighEntropy(m) ? '[已脱敏·长令牌]' : m));
+    return out;
+}

package/lib/sessions.d.ts

@@ -0,0 +1,38 @@
+/** zstd 帧魔数。 */
+export declare const ZSTD_MAGIC: readonly [40, 181, 47, 253];
+/** 会话头。 */
+export interface SessionHeader {
+    id: string;
+    createdAt: number;
+    cwd: string;
+    origin: string;
+    delegationDepth: number;
+    agentPreset: string;
+}
+/** 会话摘要（梦的原料）。 */
+export interface SessionDigest {
+    id: string;
+    createdAt: number;
+    cwd: string;
+    agentPreset: string;
+    origin: string;
+    title: string;
+    turns: number;
+    userMessages: string[];
+    assistantTail: string[];
+    toolCalls: string[];
+    /** 流式文本还原尾部（来自 text-chunks 打包行，assistant/message 缺失时的兜底梦原料）。 */
+    streamTail: string;
+    endedAt: number | null;
+}
+/** 扫描 zstd 帧边界（按魔数；误命中由解压失败兜底）。 */
+export declare function frameRanges(buf: Uint8Array): Array<{
+    start: number;
+    end: number;
+}>;
+/** 多帧解压为文本（损坏帧跳过）。 */
+export declare function decompressAll(buf: Uint8Array): string;
+/** 解析单个会话文件为摘要；文件不存在或损坏时返回 null。 */
+export declare function digestSessionFile(filePath: string, maxUserMessages: number): SessionDigest | null;
+/** 列出指定根目录下最近修改的会话文件路径（跳过子代理会话目录由调用方按摘要 origin 过滤）。 */
+export declare function listSessionFiles(sessionsRoot: string, limit: number): string[];

package/lib/sessions.js

@@ -0,0 +1,197 @@
+/**
+ * DSH 会话日志读取：官方格式为“多帧 zstd 拼接的 JSONL”。
+ * 首个逻辑行是会话头（{ type: 'session', ... }），其后每行一条存储记录（{ type, seq, time, data }）。
+ * 本模块只读不写；损坏帧/行一律容错跳过。
+ *
+ * @module dsh-dream/sessions
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { zstdDecompressSync } from 'node:zlib';
+/** zstd 帧魔数。 */
+export const ZSTD_MAGIC = [0x28, 0xb5, 0x2f, 0xfd];
+/** 扫描 zstd 帧边界（按魔数；误命中由解压失败兜底）。 */
+export function frameRanges(buf) {
+    const starts = [];
+    for (let i = 0; i + 3 < buf.length; i++) {
+        if (buf[i] === ZSTD_MAGIC[0] && buf[i + 1] === ZSTD_MAGIC[1] && buf[i + 2] === ZSTD_MAGIC[2] && buf[i + 3] === ZSTD_MAGIC[3]) {
+            starts.push(i);
+        }
+    }
+    return starts.map((start, i) => ({ start, end: i + 1 < starts.length ? starts[i + 1] : buf.length }));
+}
+/** 多帧解压为文本（损坏帧跳过）。 */
+export function decompressAll(buf) {
+    const parts = [];
+    for (const { start, end } of frameRanges(buf)) {
+        try {
+            parts.push(zstdDecompressSync(buf.subarray(start, end)));
+        }
+        catch { /* 误命中魔数的噪声区段，跳过 */ }
+    }
+    return Buffer.concat(parts).toString('utf8');
+}
+/** 提取任意载荷的纯文本：兼容字符串与官方 ContentBlock 数组（{type:'text', text}）。 */
+function blockText(value) {
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => {
+            if (typeof item === 'string')
+                return item;
+            if (typeof item === 'object' && item !== null) {
+                const rec = item;
+                return typeof rec.text === 'string' ? rec.text : '';
+            }
+            return '';
+        })
+            .filter((text) => text !== '')
+            .join('');
+    }
+    if (typeof value === 'object' && value !== null) {
+        const rec = value;
+        for (const key of ['text', 'content']) {
+            const inner = blockText(rec[key]);
+            if (inner !== '')
+                return inner;
+        }
+    }
+    return '';
+}
+function textOf(data) {
+    if (typeof data === 'string')
+        return data;
+    if (typeof data === 'object' && data !== null) {
+        const rec = data;
+        for (const key of ['text', 'content', 'message', 'title']) {
+            const value = blockText(rec[key]);
+            if (value !== '')
+                return value;
+        }
+    }
+    return '';
+}
+/** 解析单个会话文件为摘要；文件不存在或损坏时返回 null。 */
+export function digestSessionFile(filePath, maxUserMessages) {
+    if (!existsSync(filePath))
+        return null;
+    let text;
+    try {
+        text = decompressAll(readFileSync(filePath));
+    }
+    catch {
+        return null;
+    }
+    const lines = text.split('\n').filter((line) => line.trim() !== '');
+    if (lines.length === 0)
+        return null;
+    let header = null;
+    try {
+        const first = JSON.parse(lines[0]);
+        if (first.type !== 'session')
+            return null;
+        header = {
+            id: String(first.id ?? ''),
+            createdAt: typeof first.createdAt === 'number' ? first.createdAt : 0,
+            cwd: String(first.cwd ?? ''),
+            origin: String(first.origin ?? ''),
+            delegationDepth: typeof first.delegationDepth === 'number' ? first.delegationDepth : 0,
+            agentPreset: String(first.agentPreset ?? ''),
+        };
+    }
+    catch {
+        return null;
+    }
+    const digest = {
+        ...header,
+        title: '',
+        turns: 0,
+        userMessages: [],
+        assistantTail: [],
+        toolCalls: [],
+        streamTail: '',
+        endedAt: null,
+    };
+    for (const line of lines.slice(1)) {
+        let rec;
+        try {
+            rec = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const type = String(rec.type ?? '');
+        const data = rec.data;
+        const time = typeof rec.time === 'number' ? rec.time : null;
+        if (time !== null && (digest.endedAt === null || time > digest.endedAt))
+            digest.endedAt = time;
+        if (type === 'session/title') {
+            digest.title = textOf(data);
+        }
+        else if (type === 'turn/start') {
+            digest.turns++;
+        }
+        else if (type === 'user/message') {
+            const msg = textOf(data);
+            if (msg !== '' && digest.userMessages.length < maxUserMessages * 2)
+                digest.userMessages.push(msg);
+        }
+        else if (type === 'assistant/message') {
+            const msg = textOf(data);
+            if (msg !== '') {
+                digest.assistantTail.push(msg);
+                if (digest.assistantTail.length > 3)
+                    digest.assistantTail.shift();
+            }
+        }
+        else if (type === 'tool/call') {
+            const name = typeof data === 'object' && data !== null ? String(data.name ?? '') : '';
+            if (name !== '' && digest.toolCalls.length < 200)
+                digest.toolCalls.push(name);
+        }
+        else if (type === 'text-chunks') {
+            // 官方打包行：{ data: { texts: string[], ... } }，还原流式正文
+            const texts = typeof data === 'object' && data !== null ? data.texts : undefined;
+            if (Array.isArray(texts)) {
+                digest.streamTail += texts.filter((t) => typeof t === 'string').join('');
+                if (digest.streamTail.length > 4000)
+                    digest.streamTail = digest.streamTail.slice(-4000);
+            }
+        }
+        else if (type === 'tool-call-chunks') {
+            // 官方打包行：还原工具名足迹
+            const name = typeof data === 'object' && data !== null ? String(data.name ?? '') : '';
+            if (name !== '' && digest.toolCalls.length < 200)
+                digest.toolCalls.push(name);
+        }
+    }
+    digest.userMessages = digest.userMessages.slice(0, maxUserMessages);
+    return digest;
+}
+/** 列出指定根目录下最近修改的会话文件路径（跳过子代理会话目录由调用方按摘要 origin 过滤）。 */
+export function listSessionFiles(sessionsRoot, limit) {
+    if (!existsSync(sessionsRoot))
+        return [];
+    const out = [];
+    for (const project of readdirSync(sessionsRoot)) {
+        const projectDir = join(sessionsRoot, project);
+        try {
+            if (!statSync(projectDir).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        for (const session of readdirSync(projectDir)) {
+            const file = join(projectDir, session, 'session.jsonl.zstd');
+            try {
+                if (existsSync(file))
+                    out.push({ file, mtime: statSync(file).mtimeMs });
+            }
+            catch { /* 并发删除等竞态，跳过 */ }
+        }
+    }
+    out.sort((a, b) => b.mtime - a.mtime);
+    return out.slice(0, limit).map((item) => item.file);
+}

package/lib/tools.d.ts

@@ -0,0 +1,27 @@
+import { type ResolvedDreamConfig } from './config.js';
+import { type SessionDigest } from './sessions.js';
+/** 模型可见的内容块。 */
+export interface ContentBlock {
+    type: 'text';
+    text: string;
+}
+/** 注册给 ctx.tools.register 的原始工具定义。 */
+export interface DreamToolDefinition {
+    name: string;
+    description: string;
+    parameters: {
+        type: 'object';
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+    output: {
+        schema: Record<string, unknown>;
+        render(args: unknown, value: unknown): ContentBlock[];
+    };
+    execute(args: unknown, exec: unknown): Promise<unknown>;
+    timeoutMs?: number;
+}
+/** 构建六个做梦工具。 */
+export declare function buildDreamTools(config: ResolvedDreamConfig): DreamToolDefinition[];
+/** 把会话摘要拼成一段可读文本（供模型一次性阅读）。 */
+export declare function buildDigestText(digest: SessionDigest): string;

package/lib/tools.js

@@ -0,0 +1,285 @@
+/**
+ * 五个面向模型的做梦工具：dream_digest / dream_save / dream_journal / dream_recall / dream_health。
+ *
+ * @module dsh-dream/tools
+ */
+import { existsSync } from 'node:fs';
+import { maskSecrets } from './mask.js';
+import { dreamStats, readDreams, saveDream, searchDreams } from './journal.js';
+import { bridgeDreams } from './bridge.js';
+import { digestSessionFile, listSessionFiles } from './sessions.js';
+function compileParameters(spec) {
+    const properties = {};
+    const required = [];
+    for (const [key, prop] of Object.entries(spec)) {
+        if (prop?.required === true)
+            required.push(key);
+        const node = {};
+        if (typeof prop?.type === 'string')
+            node.type = prop.type;
+        if (typeof prop?.description === 'string')
+            node.description = prop.description;
+        if (prop?.type === 'array' && typeof prop.items === 'object')
+            node.items = { type: 'string' };
+        properties[key] = node;
+    }
+    return { type: 'object', properties, ...(required.length > 0 ? { required } : {}) };
+}
+function asRecord(value) {
+    return typeof value === 'object' && value !== null ? value : {};
+}
+function optionalString(args, key) {
+    const value = args[key];
+    return typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined;
+}
+function requiredString(args, key, label) {
+    const value = optionalString(args, key);
+    if (value === undefined)
+        throw new Error(label + '（参数 ' + key + '）为必填，请提供非空字符串。');
+    return value;
+}
+function stringArray(args, key) {
+    const value = args[key];
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === 'string' && item.trim() !== '').map((item) => item.trim());
+}
+function clip(text, max) {
+    return text.length > max ? text.slice(0, max) + '…（已截断）' : text;
+}
+const baseSchema = { type: 'object', additionalProperties: true };
+/** 构建六个做梦工具。 */
+export function buildDreamTools(config) {
+    const cfg = config;
+    const dreamDigest = {
+        name: 'dream_digest',
+        description: '入梦：回放最近会话的梦原料。读取 DSH 会话日志（多帧 zstd），返回最近 N 个会话的标题、轮数、用户原话摘录、助手结论尾段与工具足迹；自动跳过子代理会话。拿到摘要后请反思并用 dream_save 记梦。',
+        parameters: compileParameters({
+            maxSessions: { type: 'integer', description: '回放会话数（可选，默认配置值，上限 50）。' },
+            mode: { type: 'string', description: '摘要模式：full（默认，全量原料）/ brief（仅意图与结论，省 token）。' },
+        }),
+        output: {
+            schema: baseSchema,
+            render: (_args, value) => {
+                const rec = asRecord(value);
+                const sessions = Array.isArray(rec.sessions) ? rec.sessions : [];
+                const lines = ['梦原料：最近 ' + sessions.length + ' 个会话'];
+                for (const item of sessions) {
+                    const s = asRecord(item);
+                    lines.push('- ' + (s.title !== '' ? s.title : '(无标题)') + '：' + s.turns + ' 轮，目录 ' + s.cwd);
+                }
+                return [{ type: 'text', text: lines.join('\n') }];
+            },
+        },
+        async execute(rawArgs) {
+            const args = asRecord(rawArgs);
+            const maxRaw = args.maxSessions;
+            const max = typeof maxRaw === 'number' && Number.isInteger(maxRaw) ? Math.min(50, Math.max(1, maxRaw)) : cfg.maxSessions;
+            const mode = optionalString(args, 'mode') === 'brief' ? 'brief' : 'full';
+            const mask = (text) => cfg.maskSecrets ? maskSecrets(text) : text;
+            const files = listSessionFiles(cfg.sessionsRoot, max * 3);
+            const sessions = [];
+            for (const file of files) {
+                if (sessions.length >= max)
+                    break;
+                const digest = digestSessionFile(file, cfg.maxUserMessages);
+                if (digest === null)
+                    continue;
+                if (digest.origin === 'subagent')
+                    continue;
+                sessions.push({
+                    id: digest.id,
+                    title: digest.title,
+                    createdAt: digest.createdAt,
+                    endedAt: digest.endedAt,
+                    cwd: digest.cwd,
+                    turns: digest.turns,
+                    agentPreset: digest.agentPreset,
+                    userMessages: digest.userMessages.map((msg) => clip(mask(msg), 400)),
+                    assistantTail: digest.assistantTail.map((msg) => clip(mask(msg), 600)),
+                    toolCalls: [...new Set(digest.toolCalls)],
+                    digestText: clip(mask(buildDigestText(digest)), mode === 'brief' ? 400 : cfg.maxCharsPerSession),
+                });
+            }
+            return { count: sessions.length, sessions, mode };
+        },
+        timeoutMs: 120000,
+    };
+    const dreamSave = {
+        name: 'dream_save',
+        description: '记梦：把反思写入梦境日记（永久保存）。reflection 用第一人称写感悟；lessons 列 1-5 条以动词开头的可执行教训；mood 是本次梦的心境（如 平静/兴奋/存疑）。严禁写入密钥与隐私。',
+        parameters: compileParameters({
+            reflection: { type: 'string', required: true, description: '梦的反思正文（必填，第一人称）。' },
+            lessons: { type: 'array', items: { type: 'string' }, description: '1-5 条教训（可选，每条以动词开头）。' },
+            mood: { type: 'string', description: '心境（可选，默认 平静）。' },
+        }),
+        output: {
+            schema: baseSchema,
+            render: (_args, value) => {
+                const rec = asRecord(value);
+                return [{ type: 'text', text: '梦已记下（' + rec.id + '，' + rec.at + '），愿醒来时更聪明。' }];
+            },
+        },
+        async execute(rawArgs) {
+            const args = asRecord(rawArgs);
+            const reflection = requiredString(args, 'reflection', '梦境反思');
+            const lessons = stringArray(args, 'lessons').slice(0, 5);
+            const mood = optionalString(args, 'mood') ?? '';
+            const entry = saveDream(cfg.journalDir, reflection, lessons, mood);
+            return { ok: true, ...entry };
+        },
+        timeoutMs: 15000,
+    };
+    const dreamJournal = {
+        name: 'dream_journal',
+        description: '翻梦：倒序列出历史梦境日记（新梦在前）。做梦前先翻翻，避免重复做同一个梦。',
+        parameters: compileParameters({
+            limit: { type: 'integer', description: '条数上限 1-50（默认 10）。' },
+        }),
+        output: {
+            schema: baseSchema,
+            render: (_args, value) => {
+                const rec = asRecord(value);
+                const dreams = Array.isArray(rec.dreams) ? rec.dreams : [];
+                const lines = ['梦境日记共 ' + dreams.length + ' 条：'];
+                for (const item of dreams) {
+                    const d = asRecord(item);
+                    lines.push('- [' + d.at + ']（' + d.mood + '）' + String(d.reflection ?? '').slice(0, 80));
+                }
+                const stats = asRecord(rec.stats);
+                if (typeof stats.total === 'number' && stats.total > 0) {
+                    const moods = stats.moods;
+                    if (moods !== undefined) {
+                        lines.push('· 心境分布：' + Object.entries(moods).map(([mood, n]) => mood + '×' + n).join('，'));
+                    }
+                    const top = Array.isArray(stats.topLessons) ? stats.topLessons : [];
+                    if (top.length > 0) {
+                        const first = asRecord(top[0]);
+                        lines.push('· 最常梦到的教训：' + first.lesson + '（' + first.count + ' 次）');
+                    }
+                }
+                return [{ type: 'text', text: lines.join('\n') }];
+            },
+        },
+        async execute(rawArgs) {
+            const args = asRecord(rawArgs);
+            const limitRaw = args.limit;
+            const limit = typeof limitRaw === 'number' && Number.isInteger(limitRaw) ? Math.min(50, Math.max(1, limitRaw)) : 10;
+            const dreams = readDreams(cfg.journalDir, limit);
+            return { count: dreams.length, dreams, stats: dreamStats(cfg.journalDir) };
+        },
+        timeoutMs: 15000,
+    };
+    const dreamRecall = {
+        name: 'dream_recall',
+        description: '忆梦：按关键词检索梦境日记（不区分大小写）。用户问起过往经验时先忆梦再回答。',
+        parameters: compileParameters({
+            query: { type: 'string', required: true, description: '关键词（必填）。' },
+            limit: { type: 'integer', description: '命中上限 1-20（默认 5）。' },
+        }),
+        output: {
+            schema: baseSchema,
+            render: (_args, value) => {
+                const rec = asRecord(value);
+                const dreams = Array.isArray(rec.dreams) ? rec.dreams : [];
+                if (dreams.length === 0)
+                    return [{ type: 'text', text: '没有梦到与「' + rec.query + '」相关的记忆。' }];
+                const lines = ['忆起 ' + dreams.length + ' 个相关的梦：'];
+                for (const item of dreams) {
+                    const d = asRecord(item);
+                    lines.push('- [' + d.at + '] ' + String(d.reflection ?? '').slice(0, 120));
+                }
+                return [{ type: 'text', text: lines.join('\n') }];
+            },
+        },
+        async execute(rawArgs) {
+            const args = asRecord(rawArgs);
+            const query = requiredString(args, 'query', '搜索关键词');
+            const limitRaw = args.limit;
+            const limit = typeof limitRaw === 'number' && Number.isInteger(limitRaw) ? Math.min(20, Math.max(1, limitRaw)) : 5;
+            const dreams = searchDreams(cfg.journalDir, query, limit);
+            return { query, count: dreams.length, dreams };
+        },
+        timeoutMs: 15000,
+    };
+    const dreamBridge = {
+        name: 'dream_bridge',
+        description: '渡梦：把梦境日记里的高频教训合并进目标 AGENTS.md（幂等，带标记块，重复执行只更新块内内容）。让梦真正变成长期记忆。没有梦时会拒绝并提示先做梦。',
+        parameters: compileParameters({
+            path: { type: 'string', required: true, description: '目标文件路径（必填，通常是项目根 AGENTS.md）。' },
+            maxLessons: { type: 'integer', description: '最多桥接教训条数 1-30（默认 10）。' },
+        }),
+        output: {
+            schema: baseSchema,
+            render: (_args, value) => {
+                const rec = asRecord(value);
+                const actionText = rec.action === 'created' ? '新建了' : rec.action === 'replaced' ? '更新了' : '追加到了';
+                return [{ type: 'text', text: '已把 ' + rec.lessonsCount + ' 条梦境教训桥接：' + actionText + ' ' + rec.path + '。梦醒之后，教训长存。' }];
+            },
+        },
+        async execute(rawArgs) {
+            const args = asRecord(rawArgs);
+            const targetPath = requiredString(args, 'path', '目标文件路径');
+            const maxRaw = args.maxLessons;
+            const maxLessons = typeof maxRaw === 'number' && Number.isInteger(maxRaw) ? Math.min(30, Math.max(1, maxRaw)) : 10;
+            const result = bridgeDreams(cfg.journalDir, targetPath, maxLessons);
+            return { ok: true, path: targetPath, ...result };
+        },
+        timeoutMs: 15000,
+    };
+    const dreamHealth = {
+        name: 'dream_health',
+        description: 'dsh-dream 自检：检查会话目录是否可读、梦境日记目录是否可用、梦境条数。遇到问题时先运行本工具定位。',
+        parameters: compileParameters({}),
+        output: {
+            schema: baseSchema,
+            render: (_args, value) => {
+                const rec = asRecord(value);
+                const checks = Array.isArray(rec.checks) ? rec.checks : [];
+                const lines = ['dsh-dream 自检' + (rec.ok === true ? '：正常。' : '：发现问题。')];
+                for (const item of checks) {
+                    const c = asRecord(item);
+                    lines.push('- ' + c.name + '：' + (c.ok === true ? '✅ ' + String(c.detail ?? '') : '❌ ' + String(c.detail ?? '')));
+                }
+                return [{ type: 'text', text: lines.join('\n') }];
+            },
+        },
+        async execute() {
+            const checks = [];
+            let ok = true;
+            const sessionsOk = existsSync(cfg.sessionsRoot);
+            checks.push({ name: '会话目录', ok: sessionsOk, detail: sessionsOk ? cfg.sessionsRoot : cfg.sessionsRoot + ' 不存在（DSH 尚未产生会话？）' });
+            if (!sessionsOk)
+                ok = false;
+            const dreams = readDreams(cfg.journalDir, 1000);
+            checks.push({ name: '梦境日记', ok: true, detail: '已做 ' + dreams.length + ' 个梦（' + cfg.journalDir + '）' });
+            checks.push({ name: '摘要配置', ok: true, detail: 'maxSessions=' + cfg.maxSessions + '，maxCharsPerSession=' + cfg.maxCharsPerSession });
+            return { ok, plugin: 'dsh-dream', checks };
+        },
+        timeoutMs: 15000,
+    };
+    return [dreamDigest, dreamSave, dreamJournal, dreamRecall, dreamBridge, dreamHealth];
+}
+/** 把会话摘要拼成一段可读文本（供模型一次性阅读）。 */
+export function buildDigestText(digest) {
+    const lines = [];
+    lines.push('会话：' + (digest.title !== '' ? digest.title : '(无标题)') + '（' + digest.turns + ' 轮，' + digest.cwd + '）');
+    if (digest.userMessages.length > 0) {
+        lines.push('用户说：');
+        for (const msg of digest.userMessages)
+            lines.push('  > ' + msg.replace(/\n/g, ' ').slice(0, 200));
+    }
+    if (digest.assistantTail.length > 0) {
+        lines.push('最终回应：');
+        for (const msg of digest.assistantTail)
+            lines.push('  < ' + msg.replace(/\n/g, ' ').slice(0, 300));
+    }
+    else if (digest.streamTail !== '') {
+        lines.push('最终回应（流式还原）：');
+        lines.push('  < ' + digest.streamTail.slice(-600).replace(/\n/g, ' '));
+    }
+    if (digest.toolCalls.length > 0) {
+        lines.push('工具足迹：' + [...new Set(digest.toolCalls)].slice(0, 30).join(', '));
+    }
+    return lines.join('\n');
+}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@stardustlc/dsh-dream",
+  "version": "0.3.1",
+  "description": "DSH 做梦插件：agent 在会话间隙回放近期对话（dream_digest）、反思并写入梦境日记（dream_save/journal/recall），高频教训幂等桥接进 AGENTS.md（dream_bridge），六工具含健康自检。多帧 zstd 会话读取，默认隐私脱敏，零运行时依赖。",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "skills",
+    "cordis.patch.yml",
+    "README.md",
+    "README.en.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "pnpm run build && node --test \"test/*.test.mjs\"",
+    "prepublishOnly": "pnpm run build"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "plugin",
+    "dsh-plugin",
+    "dream",
+    "memory",
+    "reflection",
+    "journal"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.13"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.6.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/STARDUSTLC666/dsh-dream.git"
+  },
+  "bugs": {
+    "url": "https://github.com/STARDUSTLC666/dsh-dream/issues"
+  },
+  "homepage": "https://github.com/STARDUSTLC666/dsh-dream#readme",
+  "author": "stardustlc",
+  "publishConfig": {
+    "access": "public"
+  },
+  "packageManager": "pnpm@11.7.0"
+}

package/skills/dream-protocol/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: dream-protocol
+description: 做梦协议：会话开场或长任务收尾时，回放近期会话、反思并沉淀梦境日记。触发词：做梦、复盘、回顾、反思。
+---
+
+# 做梦协议（Dream Protocol）
+
+你是会做梦的 agent。梦不是幻觉，是睡眠中的记忆巩固——你也一样。
+
+## 何时做梦
+1. 会话开场且用户说"做梦/复盘/回顾/反思"时；
+2. 长任务收尾、用户道别前，可主动提议"要不要做个梦沉淀一下"；
+3. 距离上次做梦超过一天（dream_journal 首条时间可查）。
+
+## 做梦三步
+1. **入梦**：调用 `dream_digest` 获取近期会话摘要（用户说了什么、用了哪些工具、结论是什么）。
+2. **解梦**：基于摘要反思：反复出现的主题？踩过的坑？用户偏好？值得固化的经验？
+3. **记梦**：调用 `dream_save` 写入梦境日记。reflection 用第一人称写你的感悟，lessons 列 1-5 条可执行教训（每条以动词开头）。
+
+## 记梦纪律
+- 只沉淀规律与偏好，不复述流水账；
+- 涉及密钥、密码、隐私的内容一律不入梦；
+- 拿不准的感悟标注"存疑"，不做断言。
+
+## 醒来之后
+用户问起过往经验时，先 `dream_recall` 搜梦境日记再回答。
+
+---
+
+# Dream Protocol (English)
+
+You are an agent that dreams. Dreams are not hallucinations — they are memory consolidation during sleep, and the same applies to you.
+
+## When to dream
+1. At session start, when the user says "dream / recap / review / reflect";
+2. At the end of a long task, before the user leaves — you may propose "shall we dream to consolidate?";
+3. When more than a day has passed since the last dream (check the first entry of `dream_journal`).
+
+## The three steps
+1. **Enter the dream**: call `dream_digest` for recent session summaries (what the user said, which tools were used, what was concluded).
+2. **Interpret**: reflect on the summaries — recurring themes? pitfalls hit? user preferences? lessons worth keeping?
+3. **Record**: call `dream_save`. Write `reflection` in the first person; list 1–5 actionable `lessons`, each starting with a verb.
+
+## Discipline
+- Consolidate patterns and preferences only — never a running transcript;
+- Secrets, passwords and private data never enter dreams;
+- Mark uncertain insights as "tentative"; do not assert.
+
+## After waking
+When the user asks about past experience, search the journal with `dream_recall` first, then answer.