@modusensus/dsh-mneme 0.7.6 → 0.7.8

package/.github/workflows/publish.yml

@@ -2,6 +2,11 @@ name: Publish to npm
 
 # 发布路径：registry.npmjs.org 在本机云服务器被出口 SNI 过滤 + 17897 隧道不稳定，
 # 改由 GitHub runner 发布（不依赖本机出网）。打 v* tag 自动触发，或 workflow_dispatch 手动。
+#
+# ⚠️ 版本号机制（血的教训）：
+#   root package.json 在 git 里永远停在 0.7.2，真实版本号在 dsh-mneme/package.json。
+#   npm 在跑 prepublishOnly 之前就已加载 manifest，脚本里改 root 版本不生效，
+#   会把 root 的旧版本（0.7.2）发出去。必须在 npm publish 之前显式同步 root 版本。
 
 on:
   push:
@@ -23,15 +28,30 @@ jobs:
           node-version: 24
           registry-url: https://registry.npmjs.org/
 
-      # npm publish 必须从仓库根跑（根 package.json main → ./dsh-mneme/lib/index.js）。
-      # prepublishOnly 会把 dsh-mneme/package.json 的版本写回根 package.json，
-      # 所以发出的版本永远跟随 dsh-mneme/ 子目录版本号。
-      - name: Publish @modusensus/dsh-mneme
-        run: npm publish
+      - name: Registry current state (diagnostic)
+        run: |
+          npm view @modusensus/dsh-mneme versions --json || true
+          npm view @modusensus/dsh-mneme time --json || true
+
+      # 关键：先同步 root 版本 → 再 publish（prepublishOnly 改版本不可靠）
+      - name: Sync root version from dsh-mneme
+        run: |
+          V="$(node -p "require('./dsh-mneme/package.json').version")"
+          echo "Syncing root package.json to v${V}"
+          node -e "const fs=require('fs');const v=process.argv[1];const p=JSON.parse(fs.readFileSync('./package.json','utf8'));p.version=v;fs.writeFileSync('./package.json',JSON.stringify(p,null,2)+'\n')" "$V"
+          node -p "console.log('root now:', require('./package.json').version)"
+
+      - name: Publish @modusensus/dsh-mneme (skip if exists)
+        run: |
+          V="$(node -p "require('./dsh-mneme/package.json').version")"
+          if npm view "@modusensus/dsh-mneme@${V}" version >/dev/null 2>&1; then
+            echo "v${V} already published on registry — skipping"
+          else
+            npm publish
+          fi
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
 
-      # 发布后自检：查 registry 上刚发的版本是否可读
       - name: Verify published version
         run: |
           V="$(node -p "require('./dsh-mneme/package.json').version")"

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog
 
-> **完整版本历史见 [dsh-mneme/CHANGELOG.md](dsh-mneme/CHANGELOG.md)**（正式版本正源，0.3.8 → 0.7.6）。以下为仓库早期开发记录（0.1.0–0.2.x，2026-08-13~14，已归档）。
+> **完整版本历史见 [dsh-mneme/CHANGELOG.md](dsh-mneme/CHANGELOG.md)**（正式版本正源，0.3.8 → 0.7.8）。以下为仓库早期开发记录（0.1.0–0.2.x，2026-08-13~14，已归档）。
 
 All notable changes to dsh-mneme are documented here.
 

package/CONTRIBUTING.md

@@ -102,6 +102,22 @@ Common scripts (all run under `dsh-mneme/`):
 
 ---
 
+## Scope: Platform Adaptation & Wrapper PRs
+
+DSH upstream is still in developer preview — APIs and service interfaces change frequently. Until DSH reaches a stable release (RC or GA), **PRs that adapt dsh-mneme to secondary platforms or wrap it into other hosts are not a priority** and are reviewed with extra caution:
+
+- Desktop shells (e.g. a Tauri/Electron wrapper around `dsh web`)
+- Standalone CLI packaging
+- Ports/wrappers of dsh-mneme into other plugin ecosystems
+
+These tend to bind against unstable upstream APIs: a single upstream change can break them, and the maintenance burden falls back on this project. The currently supported platform is the **Web Profile** (`dsh web`).
+
+Exceptions: if a contributor is willing to **own long-term maintenance** (track upstream changes and fix breakage), open a Discussion first to scope the work — maintainers will evaluate and review the PR.
+
+Bug-fix PRs for existing desktop compatibility issues are still welcome.
+
+---
+
 ## Release Process (Maintainers)
 
 Versioning follows semantic versioning (`MAJOR.MINOR.PATCH`). Full flow:
@@ -226,6 +242,22 @@ npm run test:coverage # c8 覆盖率
 
 ---
 
+## 范围：平台适配与封装 PR
+
+DSH 上游仍处于 developer preview 阶段，API 与服务接口变动频繁。在 DSH 稳定（RC 或正式版）之前，以下方向的 PR **不作为优先项**，且会以额外谨慎的态度审查：
+
+- 桌面端适配（例如基于 `dsh web` 的 Tauri/Electron 桌面壳）
+- 独立 CLI 封装
+- 把 dsh-mneme 移植/封装到其他插件体系
+
+这类 PR 往往绑定不稳定的上游接口——上游一次变动就可能使其失效，而维护责任会落到本项目头上。当前唯一受支持的平台是 **Web Profile**（`dsh web`）。
+
+例外：如果贡献者愿意**承担长期维护**（跟进上游变更并修复 break），请先开 Discussion 沟通范围，维护者会评估并 review 该 PR。
+
+针对现有 desktop 兼容问题的 **bug 修复 PR 依然欢迎**。
+
+---
+
 ## 发布流程（维护者）
 
 版本号遵循语义化版本（`MAJOR.MINOR.PATCH`）。完整流程：

package/README.md

@@ -5,14 +5,14 @@
 <h1 align="center">dsh-mneme</h1>
 
 <p align="center">
-  <a href="https://www.npmjs.com/package/@modusensus/dsh-mneme"><img src="https://img.shields.io/npm/v/@modusensus/dsh-mneme?color=blue&label=npm" alt="npm version"></a>
-  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-green" alt="license"></a>
+  <a href="https://www.npmjs.com/package/@modusensus/dsh-mneme"><img src="https://img.shields.io/npm/v/@modusensus/dsh-mneme?style=flat-square&color=3E63DD&label=npm" alt="npm version"></a>
+  <a href="https://www.npmjs.com/package/@modusensus/dsh-mneme"><img src="https://img.shields.io/npm/dm/@modusensus/dsh-mneme?style=flat-square&color=3E63DD&label=downloads" alt="npm downloads"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-3E63DD?style=flat-square" alt="license"></a>
+  <a href="https://github.com/modusensus/dsh-mneme/actions"><img src="https://img.shields.io/github/actions/workflow/status/modusensus/dsh-mneme/test.yml?style=flat-square&label=CI" alt="CI"></a>
+  <a href="https://nodejs.org"><img src="https://img.shields.io/badge/node-24%2B-3E63DD?style=flat-square&logo=nodedotjs&logoColor=white" alt="node"></a>
+  <a href="https://github.com/modusensus/dsh-mneme"><img src="https://img.shields.io/badge/tests-812%20passed-3E63DD?style=flat-square" alt="tests"></a>
+  <a href="https://codecov.io/gh/modusensus/dsh-mneme"><img src="https://img.shields.io/codecov/c/github/modusensus/dsh-mneme/main?style=flat-square" alt="coverage"></a>
   <a href="https://github.com/awesome-dsh-plugin/awesome-dsh-plugin"><img src="https://awesome-dsh-plugin.com/badge.svg" alt="Awesome"></a>
-  <a href="https://github.com/modusensus/dsh-mneme/actions"><img src="https://img.shields.io/github/actions/workflow/status/modusensus/dsh-mneme/test.yml" alt="CI"></a>
-  <a href="https://nodejs.org"><img src="https://img.shields.io/badge/node-24%2B-blue" alt="node"></a>
-  <a href="https://github.com/modusensus/dsh-mneme"><img src="https://img.shields.io/badge/tests-801%20passed-success" alt="tests"></a>
-  <a href="https://www.npmjs.com/package/@modusensus/dsh-mneme"><img src="https://img.shields.io/npm/dm/@modusensus/dsh-mneme?color=blue&label=downloads" alt="npm downloads"></a>
-  <a href="https://codecov.io/gh/modusensus/dsh-mneme"><img src="https://img.shields.io/codecov/c/github/modusensus/dsh-mneme/main" alt="coverage"></a>
 </p>
 
 <p align="center"><strong><a href="#中文">中文</a> | <a href="#english">English</a></strong></p>
@@ -109,6 +109,8 @@ dsh web
 | **v0.7.4** | issue #40 记忆花括号转义 + issue #41 记忆窗口关闭按钮重叠修复 | ✅ |
 | **v0.7.5** | 分层记忆类型 user/fact + Web 总览视图 + stats 端点 | ✅ |
 | **v0.7.6** | issue #48 修复：截断/前缀 id 也能精确操作（统一 resolveMemoryId）+ client.js 改 src 正源 | ✅ |
+| **v0.7.7** | issue #23 图谱回填：sleep 批量实体抽取 phase + node:sqlite 兼容修复 | ✅ |
+| **v0.7.8** | issues #58 #59 修复：DSH 0.1.2-rc.1 兼容——Session.events 改为 snapshotEvents() 垫片，autoSummarize 与 hot-context 注入恢复 | ✅ |
 | **v0.8.0** | 图谱增强：兴趣漂移可视化 + scope 隔离（issue #17）+ 跨 workspace 共享 | 🚧 计划中（9 月末） |
 
 ## 🧪 本地开发
@@ -116,7 +118,7 @@ dsh web
 ```bash
 cd dsh-mneme
 npm install
-npm test          # 801 个测试
+npm test          # 812 个测试
 npm run stress    # 三轴线压测
 npm run sync      # src → lib 同步
 ```
@@ -216,6 +218,8 @@ Works out of the box. Enable these as needed:
 | **v0.7.4** | Issue #40 prompt-brace escaping + Issue #41 overlay close-button overlap fix | ✅ |
 | **v0.7.5** | Layered memory types (user/fact) + Overview view + stats endpoint | ✅ |
 | **v0.7.6** | Issue #48 fix: truncated/prefix ids resolve for exact ops (unified resolveMemoryId) + client.js now src-authored | ✅ |
+| **v0.7.7** | Issue #23 graph backfill: sleep batch entity extraction phase + node:sqlite compat fix | ✅ |
+| **v0.7.8** | Issues #58 #59 fix: DSH 0.1.2-rc.1 compat — Session.events moved to snapshotEvents() shim; autoSummarize & hot-context injection restored | ✅ |
 | **v0.8.0** | Graph enhancement: interest-drift visualization + scope isolation (issue #17) + cross-workspace sharing | 🚧 Planned (late Sep) |
 
 ## 🧪 Local Development
@@ -223,7 +227,7 @@ Works out of the box. Enable these as needed:
 ```bash
 cd dsh-mneme
 npm install
-npm test          # 801 tests
+npm test          # 812 tests
 npm run stress    # three-axis stress test
 npm run sync      # src → lib sync
 ```

package/SECURITY.md

@@ -56,7 +56,7 @@ The following security features are implemented and maintained in the project:
 
 ### Please DO
 
-1. **Email** `guanqishi26@gmail.com` (or open a **private security advisory** via [GitHub Security Advisories](https://github.com/modusensus/dsh-mneme/security/advisories))
+1. **Email** `work@modusensus.space` (or open a **private security advisory** via [GitHub Security Advisories](https://github.com/modusensus/dsh-mneme/security/advisories))
 2. Include:
    - A clear description of the vulnerability
    - Steps to reproduce (minimal test case preferred)
@@ -392,7 +392,7 @@ This project is licensed under the **MIT License**. See [LICENSE](https://github
 
 ### 请这样做
 
-1. **发送邮件**至 `guanqishi26@gmail.com`（或通过 [GitHub 私有安全公告](https://github.com/modusensus/dsh-mneme/security/advisories) 提交）
+1. **发送邮件**至 `work@modusensus.space`（或通过 [GitHub 私有安全公告](https://github.com/modusensus/dsh-mneme/security/advisories) 提交）
 2. 邮件内容请包含：
    - 漏洞的清晰描述
    - 复现步骤（优先提供最小测试用例）
@@ -671,4 +671,4 @@ dsh-mneme:
 ---
 
 *Last updated: 2026-08-28*  
-*Policy version: 2.2*
+*Policy version: 2.2*

package/dsh-mneme/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [0.7.8] - 2026-09-06
+
+### 🐛 修复：DSH 0.1.2-rc.1 兼容（issues #58 #59）
+
+- **现象**：DSH 0.1.2-rc.1 起官方移除 `Session.events` 属性、改为 `snapshotEvents()` 方法。autoSummarize（会话摘要）与 hot-context（短期上下文）注入都依赖 `session.events` 读取会话事件，升级后取到 undefined 而**静默失效**——会话摘要不再落库、短期上下文块不再渲染。
+- **修复**：`src/summarize.js` 与 `src/inject.js` 两处取事件统一改为兼容垫片 `session.snapshotEvents?.() ?? session.events`——0.1.2-rc.1 及以后走新方法，更早 0.1.x 仍走 `.events`，**新旧 DSH 通吃**。
+- **说明**：兼容垫片，老版本 DSH（0.1.x 早期）行为完全不受影响，无需任何配置改动。
+- 新增 2 个回归用例（会话只提供 `snapshotEvents()` 时 hot-context 渲染与会话摘要均恢复），全套 **812 通过**。
+
+## [0.7.7] - 2026-09-05
+
+### 🆕 issue #23：sleep 批量实体抽取回填实体图谱
+
+- **背景**：写路径抽取（index.js）只有 `entityExtractionEnabled` 开启才触发——每次写入一次 LLM 调用，是刻意的成本取舍——所以默认安装下记忆从不累积实体，这正是 issue #23 报的"实体图谱面板一片空白"（用户明明有很多记忆）。
+- **新增 sleep 批量抽取 phase**：默认关 `sleepEntityExtractionEnabled`，开睡循环时按**最老优先**把没有实体属性的记忆逐条过 `extractEntities`（每轮上限 `sleepEntityExtractionMaxPerRun` 默认 20）。
+- **下沉为有界 SQL 查询**：新增 `store.listForEntityExtraction({limit, offset})`，`WHERE` 只留行级条件（未归档/未遗忘/非 summary/内容非空/`metadata.entity_extracted_at` 为空），`ORDER BY created_at LIMIT ? OFFSET ?` 分页取最老候选；实体是否已存在是跨表检查（`getAttrsByMemory`），由 JS 在每页上过滤。不再 `service.all()` 全表加载。
+- **幂等防重**：抽取前先 stamp `metadata.pending_extracted_at`，成功后替换为 `entity_extracted_at`，失败清除 pending——一条记忆不会被并发/崩溃重复抽取，失败的下轮重试。
+- **metadata 合并不覆盖**：`store.setMemoryMetadata` 改为 merge 语义，打实体时间戳不会抹掉其他路径刚写入的 metadata 字段。
+- **失败不阻断**：单条抽取失败只跳过该条、记入 `failed` 计数，整轮状态由 `deriveStatus` 正确折叠 `failed`——一次 LLM 抖动不会 abort 整个 sleep 周期。
+- **node:sqlite 兼容修复**：初版实现用 better-sqlite3 的 `.pluck()`（node:sqlite 不存在），改为 `.all().map(row => getById(row.id))`；`listForEntityExtraction` 的 `forgotten IS NULL` 条件与 `save` 硬编码写入的 `forgotten=0` 永不匹配导致查询恒空，修正为 `(forgotten = 0 OR forgotten IS NULL)`（与 archived 同构）。
+- 新增 9 个用例（禁用/跳过、stamp 不重复、无实体也 stamp、backfill、失败重试、metadata merge、pending 清除、failed 状态折叠、分页最老优先），全套 **810 通过**。
+
 ## [0.7.6] - 2026-09-02
 
 ### 🐛 issue #48：截断的短 id 也能精确操作

package/dsh-mneme/README.md

@@ -5,7 +5,7 @@
 [![npm version](https://img.shields.io/npm/v/@modusensus/dsh-mneme?color=blue&label=npm)](https://www.npmjs.com/package/@modusensus/dsh-mneme)
 [![license](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 [![Awesome](https://awesome-dsh-plugin.com/badge.svg)](https://github.com/awesome-dsh-plugin/awesome-dsh-plugin)
-[![tests](https://img.shields.io/badge/tests-801%20passed-success)](https://github.com/modusensus/dsh-mneme)
+[![tests](https://img.shields.io/badge/tests-812%20passed-success)](https://github.com/modusensus/dsh-mneme)
 [![CI](https://img.shields.io/github/actions/workflow/status/modusensus/dsh-mneme/test.yml)](https://github.com/modusensus/dsh-mneme/actions)
 [![node](https://img.shields.io/badge/node-24%2B-blue)](https://nodejs.org)
 [![npm downloads](https://img.shields.io/npm/dm/@modusensus/dsh-mneme?color=blue&label=downloads)](https://www.npmjs.com/package/@modusensus/dsh-mneme)
@@ -241,6 +241,8 @@ v0.3.0 起新增**记忆基因**层：从记忆里抽取**命名实体**、**带
 
 | 版本 | 亮点 |
 |------|------|
+| **v0.7.8** | DSH 0.1.2-rc.1 兼容（issues #58 #59）：官方移除 `Session.events` 属性改为 `snapshotEvents()` 方法，autoSummarize 与 hot-context（短期上下文）注入取不到事件而失效；改用兼容垫片 `session.snapshotEvents?.() ?? session.events`，新旧 DSH 通吃，老版本行为不受影响；新增 2 个回归用例；812 测试全绿 |
+| **v0.7.7** | issue #23 实体图谱回填：sleep 批量实体抽取 phase（`sleepEntityExtractionEnabled` 默认关；最老优先、SQL LIMIT/OFFSET 分页下沉为有界查询不整表扫描；`pending_extracted_at` 幂等防重、成功/失败清除；metadata 合并不覆盖其他路径写入）；node:sqlite 兼容修复（pluck→all+map、`forgotten=0` 查询条件）；810 测试全绿 |
 | **v0.7.6** | issue #48 修复：`memory_update`/`memory_delete`/`memory_forget`/`memory_archive` 支持截断/前缀短 id（新增 `service.resolveMemoryId`：精确命中优先 + 唯一前缀解析 + 多命中拒绝列出候选 + `memory_delete` 未命中幂等补 `logger.warn`；纯通配符/空白兜底）；Web bundle `client.js` 改 src 正源；801 测试全绿 |
 | **v0.7.5** | 分层记忆类型：新增 `user`（用户画像）/`fact`（原子事实）轻量记忆类型（单表 `type` 扩展，不动 schema）+ Web 面板「总览」视图（记忆分层卡片 + 用户画像卡 + 类型分布 + 近 7 天趋势）+ `/api/dsh-mneme/stats` 统计端点；kimi-k2.7-code 复验（days 整数化等）；790 测试全绿 |
 | **v0.7.4** | issue #40 修复：记忆内容含 `{{...}}` 模板语法时整轮崩溃（注入边界 run-based 花括号转义 `{{a}}`→`{\{a\}\}`，奇数连续如 `{{{a}}}` 也不残留字面 `{{`；新增 `escapePromptVariables` 配置默认开）；issue #41 修复：记忆窗口关闭按钮与宿主窗口控制按钮重叠无法点击（顶栏左对齐，关闭按钮离开右上角宿主控制区）；782 测试全绿 |
@@ -296,6 +298,8 @@ v0.3.0 起新增**记忆基因**层：从记忆里抽取**命名实体**、**带
 | **v0.7.3** | ✅ 完成 | issue #38 新功能 | 左下角入口按钮可选开关 `showSidebarTrigger`（默认开，settings-over-config）；Web 面板设置一键关闭，与 dsh-cost-meter 等 footer 插件冲突可隐藏按钮、记忆库标签不受影响；776 测试全绿 |
 | **v0.7.4** | ✅ 完成 | issue #40 + #41 修复 | 注入边界 run-based 花括号转义（`{{a}}`→`{\{a\}\}`、奇数连续如 `{{{a}}}` 不残留字面，`escapePromptVariables` 默认开）+ 记忆窗口顶栏左对齐、关闭按钮避开宿主窗口控制按钮区；782 测试全绿 |
 | **v0.7.5** | ✅ 完成 | 分层记忆类型 + 总览视图 | 借鉴 meow-memory 分层概念、贴合单表架构：新增 `user`（用户画像）/`fact`（原子事实）类型，注入/镜像/梦境/质量过滤全链路打通；Web 面板「总览」视图（分层卡片 + 用户画像卡 + 类型分布 + 近 7 天趋势）；`/api/dsh-mneme/stats` 端点；kimi-k2.7-code 复验；790 测试全绿 |
+| **v0.7.7** | ✅ 完成 | issue #23 图谱回填 | sleep 批量实体抽取 phase：默认关 `sleepEntityExtractionEnabled`，按最老优先、SQL LIMIT/OFFSET 分页（下沉为有界查询，不再整表扫描）批量抽取未打标记忆的实体（修复 issue #23 实体图谱空白）；`pending_extracted_at` 幂等防重、成功/失败清除，metadata 合并不覆盖；node:sqlite 兼容修复（pluck→all+map、`forgotten=0` 查询条件）；810 测试全绿 |
+| **v0.7.8** | ✅ 完成 | DSH 0.1.2-rc.1 兼容（issues #58 #59） | 官方移除 `Session.events` 属性、改用 `snapshotEvents()` 方法后 autoSummarize 与 hot-context 注入失效；改为兼容垫片 `session.snapshotEvents?.() ?? session.events`，新旧 DSH 通吃，老版本不受影响；新增 2 个回归用例；812 测试全绿 |
 | **v0.7.6** | ✅ 完成 | issue #48 修复 | 四工具统一 `service.resolveMemoryId`：截断/前缀短 id 也能精确操作（精确命中优先、唯一前缀解析、多命中拒绝并列出候选、`memory_delete` 未命中幂等返回 + `logger.warn` 留痕）；Web bundle `client.js` 改 src 正源；801 测试全绿 |
 | **v0.8.0** | 🚧 计划中（9 月末） | 图谱增强 | 兴趣漂移可视化 + scope 隔离（issue #17）+ 跨 workspace 记忆共享 + 更多 heat 信号 |
 
@@ -305,7 +309,7 @@ v0.3.0 起新增**记忆基因**层：从记忆里抽取**命名实体**、**带
 
 ### 前置条件
 
-- [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)（DSH）
+- [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)（DSH）— 兼容 DSH 0.1.x，已验证 0.1.2-rc.1（`Session.events` → `snapshotEvents()` 变更已由插件垫片兼容，新旧版本通吃）
 - Node 24+（`node:sqlite`）
 
 ### 安装步骤
@@ -462,7 +466,7 @@ src/
 ├── client.js         # Web 面板 bundle（ModuleLoader 自注册；v0.7.6 起 src 正源）
 └── index.js          # 插件接线
 lib/                  # src 的同步分发产物（npm run sync，prepack 自动执行；无手写例外）
-test/                 # 801 个 node:test 测试（含审计与三轴线压测不变量）
+test/                 # 812 个 node:test 测试（含审计与三轴线压测不变量）
 scripts/              # e2e-dsh.js 端到端演示 · stress-dsh.js 三轴线压测 · sync-lib.js 同步 · benchmark-recall.js 召回基准
 ```
 
@@ -471,7 +475,7 @@ scripts/              # e2e-dsh.js 端到端演示 · stress-dsh.js 三轴线压
 ```bash
 cd dsh-mneme
 npm install        # 安装 peer 依赖（以 devDependencies 形式，用于本地测试）
-npm test           # 运行 801 个测试
+npm test           # 运行 812 个测试
 npm run stress     # 三轴线压测：长会话检索 / 冲突仲裁 / 多 Agent 并发（离线 mock LLM）
 npm run sync       # 把 src/ 同步到 lib/（发布时由 prepack 钩子自动执行）
 ```

package/dsh-mneme/lib/config.js

@@ -274,6 +274,15 @@ export const Config = z.object({
     z.const("high"),
     z.const("none")
   ]).default("none"),
+  // Batch entity extraction during sleep (issue #23). The write-path extractor
+  // only fires when entityExtractionEnabled is on (an LLM call per write);
+  // this additive phase backfills entities/attrs/relations for memories that
+  // never went through it, so stores that leave the write-path extractor off
+  // still accumulate an ego graph as long as sleep runs. On by default (it is
+  // a no-op until a sleep cycle fires), capped per run to bound token spend.
+  sleepEntityExtractionEnabled: z.boolean().default(true),
+  // Max memories entity-extracted per sleep run (oldest un-extracted first).
+  sleepEntityExtractionMaxPerRun: z.natural().min(1).max(100).default(20),
 
   // --- epistemic trust: memory source credibility (v0.4.5) -----------------
   // Distinguish memories by source: observation (measured / witnessed),

package/dsh-mneme/lib/dream/sleep.js

@@ -19,6 +19,7 @@ import { validateDecisions, applyDecisions } from "./decisions.js";
 import { findPotentialConflicts } from "./clustering.js";
 import { buildReceipt } from "../dream.js";
 import { computeHeat } from "../heat.js";
+import { extractEntities } from "../entities/extractor.js";
 
 const SUMMARY_MAX = 120;
 // Conflict similarity threshold per strictness level (v0.4.0):
@@ -396,6 +397,123 @@ function phaseRelations(service, config, logger, runId, signal = null) {
   };
 }
 
+/**
+ * Phase 4.5 — batch entity extraction. The write-path extractor (index.js)
+ * only fires when entityExtractionEnabled is on — one LLM call per write, a
+ * deliberate cost decision — so default installs never accumulate entities,
+ * which is exactly why the ego-graph panel (issue #23) renders blank for users
+ * with plenty of memories. This phase backfills the entity graph in bulk:
+ * memories that carry no entity attrs yet are passed through extractEntities
+ * one at a time (oldest first, capped per run). Write-path stays untouched —
+ * this is an additive channel for sleep users. Fail-safe per memory: one bad
+ * extract never aborts the phase or the cycle.
+ */
+async function phaseEntityExtraction(ctx, service, config, logger, runId, signal = null) {
+  if (config.sleepEntityExtractionEnabled !== true) {
+    return { status: "skipped", reason: "disabled" };
+  }
+  const route = resolveSleepRoute(ctx, config, logger);
+  if (!route) return { status: "skipped", reason: "no llm route" };
+  const maxPerRun = config.sleepEntityExtractionMaxPerRun ?? 20;
+
+  // Oldest un-extracted first. The store returns bounded pages via SQL (no
+  // O(N) full-table scan); JS pages through offsets and only pays the
+  // getAttrsByMemory cross-table check on each page, stopping once it has
+  // maxPerRun un-extracted memories or the store is exhausted. Every memory
+  // this phase touches gets stamped entity_extracted_at (successful or
+  // entity-less extracts alike) so a text with no extractable entities is not
+  // re-queued forever; failures are NOT stamped, so a transient LLM hiccup
+  // retries next cycle.
+  const candidates = [];
+  for (let offset = 0; candidates.length < maxPerRun; offset += 100) {
+    const page = service.listForEntityExtraction({ limit: 100, offset });
+    if (page.length === 0) break;
+    candidates.push(...page.filter((m) => (service.getAttrsByMemory?.(m.id) ?? []).length === 0));
+  }
+  candidates.length = Math.min(candidates.length, maxPerRun);
+  if (candidates.length === 0) return { status: "skipped", reason: "no memories to extract" };
+  if (signal?.aborted) return { status: "aborted", reason: "user activity" };
+
+  // extractEntities expects callLLM(messages, options) → text; adapt sleep's
+  // streamText + route resolution (same precedence as the other phases).
+  const callLLM = async (messages) => {
+    const r = resolveSleepRoute(ctx, config, logger);
+    if (!r) return undefined;
+    return streamText(ctx, {
+      ...r,
+      purpose: "sleep-entity-extract",
+      maxTokens: 4096,
+      ...(config.sleepReasoningEffort && config.sleepReasoningEffort !== "none"
+        ? { reasoningEffort: config.sleepReasoningEffort }
+        : {}),
+      messages
+    });
+  };
+
+  let extracted = 0;
+  let failed = 0;
+  let aborted = false;
+  const extractedIds = [];
+  for (const m of candidates) {
+    if (signal?.aborted) {
+      aborted = true;
+      break;
+    }
+    const now = new Date().toISOString();
+    try {
+      // Stamp a pending marker BEFORE the LLM call so a crash mid-extract (the
+      // stamp and the entity writes are not one transaction) cannot re-queue
+      // this memory while we are already working it. Cleared on outcome.
+      service.setMemoryMetadata?.(m.id, { pending_extracted_at: now });
+    } catch (error) {
+      logger?.warn?.(`dsh-mneme sleep: failed to stamp pending_extracted_at for ${m.id}: ${String(error)}`);
+      failed++;
+      continue;
+    }
+    try {
+      const result = await extractEntities(m, { store: service, config, callLLM, logger });
+      if (result?.ok) {
+        extracted++;
+        extractedIds.push(m.id);
+        // Stamp done regardless of whether the LLM found entities — an empty
+        // extract is still a definitive answer for this memory.
+        try {
+          service.setMemoryMetadata?.(m.id, { entity_extracted_at: now, pending_extracted_at: null });
+        } catch (error) {
+          logger?.warn?.(`dsh-mneme sleep: failed to stamp entity_extracted_at for ${m.id}: ${String(error)}`);
+        }
+      } else {
+        failed++;
+        logger?.warn?.(`dsh-mneme sleep: entity extraction failed for ${m.id}: ${result?.error ?? "unknown"}`);
+        try {
+          service.setMemoryMetadata?.(m.id, { pending_extracted_at: null });
+        } catch (error) {
+          logger?.warn?.(`dsh-mneme sleep: failed to clear pending_extracted_at for ${m.id}: ${String(error)}`);
+        }
+      }
+    } catch (error) {
+      failed++;
+      logger?.warn?.(`dsh-mneme sleep: entity extraction threw for ${m.id}: ${String(error)}`);
+      try {
+        service.setMemoryMetadata?.(m.id, { pending_extracted_at: null });
+      } catch (err) {
+        logger?.warn?.(`dsh-mneme sleep: failed to clear pending_extracted_at for ${m.id}: ${String(err)}`);
+      }
+    }
+  }
+  return {
+    // Any success counts as ok (failures are surfaced via detail.failed + warn,
+    // matching phaseConflicts); all-failed reports failed so deriveStatus can
+    // reflect a broken route without aborting the other phases.
+    status: aborted ? "aborted" : extracted > 0 ? "ok" : failed > 0 ? "failed" : "noop",
+    scanned: candidates.length,
+    extracted,
+    failed,
+    aborted,
+    extractedIds
+  };
+}
+
 // ---------------------------------------------------------------- run
 
 function deriveStatus(phases) {
@@ -429,6 +547,9 @@ export async function runSleep(ctx, service, config, logger, semantic = null, si
   await attempt("conflicts", () => phaseConflicts(ctx, service, config, logger, runId, semantic, signal));
   await attempt("demotion", () => phaseDemotion(service, config, logger, runId, signal));
   await attempt("patterns", () => phasePatterns(ctx, service, config, logger, runId, signal));
+  // entity-extraction runs before relation completion so freshly minted
+  // entities get their orphan relations completed in the same cycle.
+  await attempt("entity-extraction", () => phaseEntityExtraction(ctx, service, config, logger, runId, signal));
   await attempt("relations", () => phaseRelations(service, config, logger, runId, signal));
 
   const status = deriveStatus(phases);

package/dsh-mneme/lib/service.js

@@ -1608,6 +1608,7 @@ export function createService({ store, mirror, config, onWrite, logger, settings
     embeddedCount: () => store.embeddedCount(),
     list: (o) => store.list(o),
     all: () => store.all(),
+    listForEntityExtraction: (opts) => store.listForEntityExtraction(opts),
     count: (type, opts) => store.count(type, opts),
     stats: (opts) => store.stats(opts),
     getById: (id) => store.getById(id),
@@ -1862,9 +1863,11 @@ export function createService({ store, mirror, config, onWrite, logger, settings
     applyMemoryTags: (memoryId, tags) => store.setMemoryTags(memoryId, tags),
     saveAttr: (r) => store.saveAttr(r),
     createEntity: (r) => store.createEntity(r),
+    updateEntity: (id, patch) => store.updateEntity(id, patch),
     findEntityByName: (n) => store.findEntityByName(n),
     findEntityById: (id) => store.findEntityById(id),
     getAttrsByMemory: (id) => store.getAttrsByMemory(id),
+    setMemoryMetadata: (id, metadata) => store.setMemoryMetadata(id, metadata),
     getCurrentAttrs: (id) => store.getCurrentAttrs(id),
     migrateAttrsToMemory: (fromId, toId, now) => store.migrateAttrsToMemory(fromId, toId, now)
   };

package/dsh-mneme/lib/store.js

@@ -20,6 +20,7 @@ CREATE TABLE IF NOT EXISTS memories (
   epistemic_status TEXT NOT NULL DEFAULT 'subjective',
   last_accessed_at  TEXT,
   _full_content     TEXT,
+  metadata    TEXT,               -- JSON: free-form extras (e.g. sleep entity_extracted_at)
   created_at  TEXT NOT NULL,
   updated_at  TEXT NOT NULL
 );
@@ -314,6 +315,14 @@ function parseTags(raw) {
 
 function toRow(row) {
   if (!row) return undefined;
+  let metadata;
+  if (row.metadata != null) {
+    try {
+      metadata = JSON.parse(row.metadata);
+    } catch {
+      metadata = row.metadata;
+    }
+  }
   return {
     id: row.id,
     type: row.type,
@@ -329,6 +338,7 @@ function toRow(row) {
     content_history: parseJsonArray(row.content_history),
     quality_score: row.quality_score !== null && row.quality_score !== undefined ? Number(row.quality_score) : undefined,
     epistemic_status: row.epistemic_status ?? "subjective",
+    metadata,
     created_at: row.created_at,
     updated_at: row.updated_at,
     last_accessed_at: row.last_accessed_at ?? undefined,
@@ -589,6 +599,7 @@ export function createStore(path) {
   addColumn("memories", "content_history", "ALTER TABLE memories ADD COLUMN content_history TEXT");
   addColumn("memories", "quality_score", "ALTER TABLE memories ADD COLUMN quality_score REAL");
   addColumn("memories", "session_id", "ALTER TABLE memories ADD COLUMN session_id TEXT");
+  addColumn("memories", "metadata", "ALTER TABLE memories ADD COLUMN metadata TEXT");
 
   // Composite index for session-lifecycle queries (dispose/restore/listBySession).
   // Created post-migration, NOT in SCHEMA: on legacy DBs both columns arrive via
@@ -834,6 +845,50 @@ export function createStore(path) {
     });
   }
 
+  /**
+   * Bounded scan for sleep's entity-extraction phase: oldest memories without
+   * an entity_extracted_at stamp (row-level filters only — attr presence is a
+   * cross-table check, so the caller filters the returned page via
+   * getAttrsByMemory). Caller pages with {limit, offset}; a full-table scan +
+   * JS filter would be O(N) per sleep cycle.
+   */
+  function listForEntityExtraction({ limit = 50, offset = 0 } = {}) {
+    // node:sqlite has no StatementSync#pluck; all() returns row objects.
+    return db
+      .prepare(`
+        SELECT id FROM memories
+        WHERE (archived = 0 OR archived IS NULL)
+          AND session_disposed_at IS NULL
+          AND (forgotten = 0 OR forgotten IS NULL)
+          AND type != 'summary'
+          AND content IS NOT NULL AND content != ''
+          AND (metadata IS NULL OR json_extract(metadata, '$.entity_extracted_at') IS NULL)
+        ORDER BY created_at ASC
+        LIMIT ? OFFSET ?
+      `)
+      .all(limit, offset)
+      .map((row) => getById(row.id));
+  }
+
+  /**
+   * Lightweight metadata-only update (used by sleep's batch entity extraction
+   * to stamp `entity_extracted_at` without disturbing title/content/embedding
+   * or the normal update semantics). Does not bump updated_at — metadata
+   * stamps are bookkeeping, not content, so they must not fake freshness.
+   * Incoming fields are MERGED into the existing metadata object so a stamp
+   * never clobbers metadata another path just wrote.
+   */
+  function setMemoryMetadata(id, metadata) {
+    const existing = getById(id);
+    if (!existing) throw new Error(`memory not found: ${id}`);
+    const patch = typeof metadata === "string"
+      ? JSON.parse(metadata)
+      : (metadata ?? {});
+    const merged = { ...(existing.metadata ?? {}), ...patch };
+    db.prepare("UPDATE memories SET metadata = ? WHERE id = ?").run(JSON.stringify(merged), id);
+    return getById(id);
+  }
+
   /**
    * Atomic compare-and-set update: applies `patch` only when the row still
    * carries `expectedUpdatedAt` (the version token read by the caller). Returns
@@ -2234,6 +2289,8 @@ export function createStore(path) {
     listByIdPrefix,
     save,
     update,
+    listForEntityExtraction,
+    setMemoryMetadata,
     compareAndUpdate,
     remove,
     setForget,

package/dsh-mneme/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@modusensus/dsh-mneme",
-  "version": "0.7.6",
+  "version": "0.7.7",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@modusensus/dsh-mneme",
-      "version": "0.7.6",
+      "version": "0.7.7",
       "license": "MIT",
       "dependencies": {
         "@huggingface/transformers": "^4.2.0"

package/dsh-mneme/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@modusensus/dsh-mneme",
   "description": "Cross-session memory plugin for DeepSeek Harness with autoDream consolidation: SQLite store, Markdown mirrors, 7 model tools, automatic injection, session summarization, user profile/rules, custom slash commands, vector (semantic) search, and a Web GUI panel",
-  "version": "0.7.6",
+  "version": "0.7.8",
   "license": "MIT",
   "repository": {
     "type": "git",

package/dsh-mneme/src/config.js

@@ -274,6 +274,15 @@ export const Config = z.object({
     z.const("high"),
     z.const("none")
   ]).default("none"),
+  // Batch entity extraction during sleep (issue #23). The write-path extractor
+  // only fires when entityExtractionEnabled is on (an LLM call per write);
+  // this additive phase backfills entities/attrs/relations for memories that
+  // never went through it, so stores that leave the write-path extractor off
+  // still accumulate an ego graph as long as sleep runs. On by default (it is
+  // a no-op until a sleep cycle fires), capped per run to bound token spend.
+  sleepEntityExtractionEnabled: z.boolean().default(true),
+  // Max memories entity-extracted per sleep run (oldest un-extracted first).
+  sleepEntityExtractionMaxPerRun: z.natural().min(1).max(100).default(20),
 
   // --- epistemic trust: memory source credibility (v0.4.5) -----------------
   // Distinguish memories by source: observation (measured / witnessed),

package/dsh-mneme/src/dream/sleep.js

@@ -19,6 +19,7 @@ import { validateDecisions, applyDecisions } from "./decisions.js";
 import { findPotentialConflicts } from "./clustering.js";
 import { buildReceipt } from "../dream.js";
 import { computeHeat } from "../heat.js";
+import { extractEntities } from "../entities/extractor.js";
 
 const SUMMARY_MAX = 120;
 // Conflict similarity threshold per strictness level (v0.4.0):
@@ -396,6 +397,123 @@ function phaseRelations(service, config, logger, runId, signal = null) {
   };
 }
 
+/**
+ * Phase 4.5 — batch entity extraction. The write-path extractor (index.js)
+ * only fires when entityExtractionEnabled is on — one LLM call per write, a
+ * deliberate cost decision — so default installs never accumulate entities,
+ * which is exactly why the ego-graph panel (issue #23) renders blank for users
+ * with plenty of memories. This phase backfills the entity graph in bulk:
+ * memories that carry no entity attrs yet are passed through extractEntities
+ * one at a time (oldest first, capped per run). Write-path stays untouched —
+ * this is an additive channel for sleep users. Fail-safe per memory: one bad
+ * extract never aborts the phase or the cycle.
+ */
+async function phaseEntityExtraction(ctx, service, config, logger, runId, signal = null) {
+  if (config.sleepEntityExtractionEnabled !== true) {
+    return { status: "skipped", reason: "disabled" };
+  }
+  const route = resolveSleepRoute(ctx, config, logger);
+  if (!route) return { status: "skipped", reason: "no llm route" };
+  const maxPerRun = config.sleepEntityExtractionMaxPerRun ?? 20;
+
+  // Oldest un-extracted first. The store returns bounded pages via SQL (no
+  // O(N) full-table scan); JS pages through offsets and only pays the
+  // getAttrsByMemory cross-table check on each page, stopping once it has
+  // maxPerRun un-extracted memories or the store is exhausted. Every memory
+  // this phase touches gets stamped entity_extracted_at (successful or
+  // entity-less extracts alike) so a text with no extractable entities is not
+  // re-queued forever; failures are NOT stamped, so a transient LLM hiccup
+  // retries next cycle.
+  const candidates = [];
+  for (let offset = 0; candidates.length < maxPerRun; offset += 100) {
+    const page = service.listForEntityExtraction({ limit: 100, offset });
+    if (page.length === 0) break;
+    candidates.push(...page.filter((m) => (service.getAttrsByMemory?.(m.id) ?? []).length === 0));
+  }
+  candidates.length = Math.min(candidates.length, maxPerRun);
+  if (candidates.length === 0) return { status: "skipped", reason: "no memories to extract" };
+  if (signal?.aborted) return { status: "aborted", reason: "user activity" };
+
+  // extractEntities expects callLLM(messages, options) → text; adapt sleep's
+  // streamText + route resolution (same precedence as the other phases).
+  const callLLM = async (messages) => {
+    const r = resolveSleepRoute(ctx, config, logger);
+    if (!r) return undefined;
+    return streamText(ctx, {
+      ...r,
+      purpose: "sleep-entity-extract",
+      maxTokens: 4096,
+      ...(config.sleepReasoningEffort && config.sleepReasoningEffort !== "none"
+        ? { reasoningEffort: config.sleepReasoningEffort }
+        : {}),
+      messages
+    });
+  };
+
+  let extracted = 0;
+  let failed = 0;
+  let aborted = false;
+  const extractedIds = [];
+  for (const m of candidates) {
+    if (signal?.aborted) {
+      aborted = true;
+      break;
+    }
+    const now = new Date().toISOString();
+    try {
+      // Stamp a pending marker BEFORE the LLM call so a crash mid-extract (the
+      // stamp and the entity writes are not one transaction) cannot re-queue
+      // this memory while we are already working it. Cleared on outcome.
+      service.setMemoryMetadata?.(m.id, { pending_extracted_at: now });
+    } catch (error) {
+      logger?.warn?.(`dsh-mneme sleep: failed to stamp pending_extracted_at for ${m.id}: ${String(error)}`);
+      failed++;
+      continue;
+    }
+    try {
+      const result = await extractEntities(m, { store: service, config, callLLM, logger });
+      if (result?.ok) {
+        extracted++;
+        extractedIds.push(m.id);
+        // Stamp done regardless of whether the LLM found entities — an empty
+        // extract is still a definitive answer for this memory.
+        try {
+          service.setMemoryMetadata?.(m.id, { entity_extracted_at: now, pending_extracted_at: null });
+        } catch (error) {
+          logger?.warn?.(`dsh-mneme sleep: failed to stamp entity_extracted_at for ${m.id}: ${String(error)}`);
+        }
+      } else {
+        failed++;
+        logger?.warn?.(`dsh-mneme sleep: entity extraction failed for ${m.id}: ${result?.error ?? "unknown"}`);
+        try {
+          service.setMemoryMetadata?.(m.id, { pending_extracted_at: null });
+        } catch (error) {
+          logger?.warn?.(`dsh-mneme sleep: failed to clear pending_extracted_at for ${m.id}: ${String(error)}`);
+        }
+      }
+    } catch (error) {
+      failed++;
+      logger?.warn?.(`dsh-mneme sleep: entity extraction threw for ${m.id}: ${String(error)}`);
+      try {
+        service.setMemoryMetadata?.(m.id, { pending_extracted_at: null });
+      } catch (err) {
+        logger?.warn?.(`dsh-mneme sleep: failed to clear pending_extracted_at for ${m.id}: ${String(err)}`);
+      }
+    }
+  }
+  return {
+    // Any success counts as ok (failures are surfaced via detail.failed + warn,
+    // matching phaseConflicts); all-failed reports failed so deriveStatus can
+    // reflect a broken route without aborting the other phases.
+    status: aborted ? "aborted" : extracted > 0 ? "ok" : failed > 0 ? "failed" : "noop",
+    scanned: candidates.length,
+    extracted,
+    failed,
+    aborted,
+    extractedIds
+  };
+}
+
 // ---------------------------------------------------------------- run
 
 function deriveStatus(phases) {
@@ -429,6 +547,9 @@ export async function runSleep(ctx, service, config, logger, semantic = null, si
   await attempt("conflicts", () => phaseConflicts(ctx, service, config, logger, runId, semantic, signal));
   await attempt("demotion", () => phaseDemotion(service, config, logger, runId, signal));
   await attempt("patterns", () => phasePatterns(ctx, service, config, logger, runId, signal));
+  // entity-extraction runs before relation completion so freshly minted
+  // entities get their orphan relations completed in the same cycle.
+  await attempt("entity-extraction", () => phaseEntityExtraction(ctx, service, config, logger, runId, signal));
   await attempt("relations", () => phaseRelations(service, config, logger, runId, signal));
 
   const status = deriveStatus(phases);

package/dsh-mneme/src/inject.js

@@ -8,7 +8,7 @@ import { createHotMemory } from "./hot-memory.js";
 // falls back to the legacy rule-based pick, never breaking the render.
 function lastUserQuery(ctx) {
   try {
-    const events = ctx?.agent?.session?.events;
+    const events = ctx?.agent?.session?.snapshotEvents?.() ?? ctx?.agent?.session?.events;
     if (!Array.isArray(events) || events.length === 0) return "";
     for (let i = events.length - 1; i >= 0; i--) {
       const event = events[i];
@@ -34,7 +34,7 @@ function lastUserQuery(ctx) {
 // returns [] on any failure, and the hot block simply does not render.
 function extractRounds(ctx, maxRounds) {
   try {
-    const events = ctx?.agent?.session?.events;
+    const events = ctx?.agent?.session?.snapshotEvents?.() ?? ctx?.agent?.session?.events;
     if (!Array.isArray(events) || events.length === 0) return [];
     const rounds = [];
     let pendingQuery = null;

package/dsh-mneme/src/service.js

@@ -1608,6 +1608,7 @@ export function createService({ store, mirror, config, onWrite, logger, settings
     embeddedCount: () => store.embeddedCount(),
     list: (o) => store.list(o),
     all: () => store.all(),
+    listForEntityExtraction: (opts) => store.listForEntityExtraction(opts),
     count: (type, opts) => store.count(type, opts),
     stats: (opts) => store.stats(opts),
     getById: (id) => store.getById(id),
@@ -1862,9 +1863,11 @@ export function createService({ store, mirror, config, onWrite, logger, settings
     applyMemoryTags: (memoryId, tags) => store.setMemoryTags(memoryId, tags),
     saveAttr: (r) => store.saveAttr(r),
     createEntity: (r) => store.createEntity(r),
+    updateEntity: (id, patch) => store.updateEntity(id, patch),
     findEntityByName: (n) => store.findEntityByName(n),
     findEntityById: (id) => store.findEntityById(id),
     getAttrsByMemory: (id) => store.getAttrsByMemory(id),
+    setMemoryMetadata: (id, metadata) => store.setMemoryMetadata(id, metadata),
     getCurrentAttrs: (id) => store.getCurrentAttrs(id),
     migrateAttrsToMemory: (fromId, toId, now) => store.migrateAttrsToMemory(fromId, toId, now)
   };

package/dsh-mneme/src/store.js

@@ -20,6 +20,7 @@ CREATE TABLE IF NOT EXISTS memories (
   epistemic_status TEXT NOT NULL DEFAULT 'subjective',
   last_accessed_at  TEXT,
   _full_content     TEXT,
+  metadata    TEXT,               -- JSON: free-form extras (e.g. sleep entity_extracted_at)
   created_at  TEXT NOT NULL,
   updated_at  TEXT NOT NULL
 );
@@ -314,6 +315,14 @@ function parseTags(raw) {
 
 function toRow(row) {
   if (!row) return undefined;
+  let metadata;
+  if (row.metadata != null) {
+    try {
+      metadata = JSON.parse(row.metadata);
+    } catch {
+      metadata = row.metadata;
+    }
+  }
   return {
     id: row.id,
     type: row.type,
@@ -329,6 +338,7 @@ function toRow(row) {
     content_history: parseJsonArray(row.content_history),
     quality_score: row.quality_score !== null && row.quality_score !== undefined ? Number(row.quality_score) : undefined,
     epistemic_status: row.epistemic_status ?? "subjective",
+    metadata,
     created_at: row.created_at,
     updated_at: row.updated_at,
     last_accessed_at: row.last_accessed_at ?? undefined,
@@ -589,6 +599,7 @@ export function createStore(path) {
   addColumn("memories", "content_history", "ALTER TABLE memories ADD COLUMN content_history TEXT");
   addColumn("memories", "quality_score", "ALTER TABLE memories ADD COLUMN quality_score REAL");
   addColumn("memories", "session_id", "ALTER TABLE memories ADD COLUMN session_id TEXT");
+  addColumn("memories", "metadata", "ALTER TABLE memories ADD COLUMN metadata TEXT");
 
   // Composite index for session-lifecycle queries (dispose/restore/listBySession).
   // Created post-migration, NOT in SCHEMA: on legacy DBs both columns arrive via
@@ -834,6 +845,50 @@ export function createStore(path) {
     });
   }
 
+  /**
+   * Bounded scan for sleep's entity-extraction phase: oldest memories without
+   * an entity_extracted_at stamp (row-level filters only — attr presence is a
+   * cross-table check, so the caller filters the returned page via
+   * getAttrsByMemory). Caller pages with {limit, offset}; a full-table scan +
+   * JS filter would be O(N) per sleep cycle.
+   */
+  function listForEntityExtraction({ limit = 50, offset = 0 } = {}) {
+    // node:sqlite has no StatementSync#pluck; all() returns row objects.
+    return db
+      .prepare(`
+        SELECT id FROM memories
+        WHERE (archived = 0 OR archived IS NULL)
+          AND session_disposed_at IS NULL
+          AND (forgotten = 0 OR forgotten IS NULL)
+          AND type != 'summary'
+          AND content IS NOT NULL AND content != ''
+          AND (metadata IS NULL OR json_extract(metadata, '$.entity_extracted_at') IS NULL)
+        ORDER BY created_at ASC
+        LIMIT ? OFFSET ?
+      `)
+      .all(limit, offset)
+      .map((row) => getById(row.id));
+  }
+
+  /**
+   * Lightweight metadata-only update (used by sleep's batch entity extraction
+   * to stamp `entity_extracted_at` without disturbing title/content/embedding
+   * or the normal update semantics). Does not bump updated_at — metadata
+   * stamps are bookkeeping, not content, so they must not fake freshness.
+   * Incoming fields are MERGED into the existing metadata object so a stamp
+   * never clobbers metadata another path just wrote.
+   */
+  function setMemoryMetadata(id, metadata) {
+    const existing = getById(id);
+    if (!existing) throw new Error(`memory not found: ${id}`);
+    const patch = typeof metadata === "string"
+      ? JSON.parse(metadata)
+      : (metadata ?? {});
+    const merged = { ...(existing.metadata ?? {}), ...patch };
+    db.prepare("UPDATE memories SET metadata = ? WHERE id = ?").run(JSON.stringify(merged), id);
+    return getById(id);
+  }
+
   /**
    * Atomic compare-and-set update: applies `patch` only when the row still
    * carries `expectedUpdatedAt` (the version token read by the caller). Returns
@@ -2234,6 +2289,8 @@ export function createStore(path) {
     listByIdPrefix,
     save,
     update,
+    listForEntityExtraction,
+    setMemoryMetadata,
     compareAndUpdate,
     remove,
     setForget,

package/dsh-mneme/src/summarize.js

@@ -78,7 +78,9 @@ function toProtocolChunk(chunk) {
 // check below.
 function collectMessages(session) {
   const messages = [];
-  for (const event of session.events ?? []) {
+  // DSH 0.1.2-rc.1 起 Session 改用 snapshotEvents()，兼容旧版 .events
+  const events = session.snapshotEvents?.() ?? session.events ?? [];
+  for (const event of events) {
     const kind = event.data?.source?.kind;
     if (event.type !== "user/message") continue;
     if (kind !== undefined && kind !== "user") continue;

package/dsh-mneme/test/inject.test.js

@@ -179,6 +179,24 @@ test("issue #40: hot-context rounds with {{...}} are escaped", () => {
   assert.ok(!text.includes("}}"), "no raw }} in hot context");
 });
 
+test("session with only snapshotEvents() (DSH 0.1.2-rc.1) still renders hot context", () => {
+  const { contexts } = setup();
+  const text = contexts[0].text({
+    agent: {
+      session: {
+        id: "s1",
+        snapshotEvents: () => [
+          { type: "user/message", data: { source: { kind: "user" }, content: ["用快照接口提问"] } },
+          { type: "assistant/message", data: { source: { kind: "assistant" }, content: ["快照返回的答复"] } }
+        ]
+      }
+    }
+  });
+  assert.ok(text.includes("[短期上下文]"), "hot context rendered");
+  assert.ok(text.includes("用快照接口提问"), "user query picked up from snapshotEvents");
+  assert.ok(text.includes("快照返回的答复"), "assistant reply picked up from snapshotEvents");
+});
+
 test("issue #40: escapePromptVariables=false passes {{...}} through verbatim", () => {
   const { contexts, service } = setup({ escapePromptVariables: false });
   service.saveWithDedupe({ type: "preference", title: "模板", content: "{{挖空}} 与 {{hl|term}}", importance: 5 });

package/dsh-mneme/test/sleep.test.js

@@ -371,3 +371,162 @@ test("sleep: runSleep is abortable via signal between phases", async () => {
   assert.equal(result.phases.conflicts, undefined, "aborted before any phase ran");
   store.close();
 });
+
+// ------------------------------------------------ entity extraction (issue #23)
+
+// Write-path extractor is gated on entityExtractionEnabled (default off), so
+// default installs never accumulate entities → ego-graph panel blank. This
+// sleep phase backfills it; these tests cover gating, idempotence and
+// fail-safe batching.
+const ENTITY_LLM_JSON = JSON.stringify({
+  entities: [{ name: "X", type: "concept", attrs: [{ key: "k", value: "v" }] }],
+  relations: []
+});
+
+test("sleep: entity extraction skips when disabled", async () => {
+  const { service, store } = setup();
+  makeMemory(service, "记忆A", "内容A", "history");
+  const ctx = mockCtx(() => ENTITY_LLM_JSON, { provider: "p", model: "m" });
+  const result = await runSleep(
+    ctx, service,
+    baseConfig({ sleepEntityExtractionEnabled: false }),
+    ctx.logger, null, null
+  );
+  assert.equal(result.phases["entity-extraction"].status, "skipped", "disabled → skipped");
+  store.close();
+});
+
+test("sleep: extracted memories are stamped and not re-extracted", async () => {
+  const { service, store } = setup();
+  const mem = makeMemory(service, "记忆B", "内容B", "history");
+  const ctx = mockCtx(() => ENTITY_LLM_JSON, { provider: "p", model: "m" });
+  const config = baseConfig({ sleepEntityExtractionEnabled: true });
+  // First cycle backfills → memory gets entity_extracted_at stamped.
+  const first = await runSleep(ctx, service, config, ctx.logger, null, null);
+  assert.equal(first.phases["entity-extraction"].status, "ok", "first cycle extracts");
+  assert.ok(service.getById(mem.id).metadata?.entity_extracted_at, "stamp written");
+  // Second cycle has nothing un-stamped left → skipped.
+  const second = await runSleep(ctx, service, config, ctx.logger, null, null);
+  assert.equal(second.phases["entity-extraction"].status, "skipped", "nothing left to extract");
+  store.close();
+});
+
+test("sleep: entity-less extracts are stamped so they are not re-queued forever", async () => {
+  const { service, store } = setup();
+  const mem = makeMemory(service, "无实体记忆", "这里没有任何实体", "history");
+  // LLM legitimately returns no entities — must still be stamped, else every
+  // sleep cycle re-extracts the same text forever (issue #23 regression).
+  const ctx = mockCtx(() => JSON.stringify({ entities: [], relations: [] }), { provider: "p", model: "m" });
+  const config = baseConfig({ sleepEntityExtractionEnabled: true });
+  const first = await runSleep(ctx, service, config, ctx.logger, null, null);
+  assert.equal(first.phases["entity-extraction"].status, "ok", "empty extract counts as handled");
+  assert.equal(first.phases["entity-extraction"].extracted, 1);
+  assert.ok(service.getById(mem.id).metadata?.entity_extracted_at, "stamp written even with no entities");
+  const second = await runSleep(ctx, service, config, ctx.logger, null, null);
+  assert.equal(second.phases["entity-extraction"].status, "skipped", "stamped → not re-queued");
+  store.close();
+});
+
+test("sleep: entity extraction backfills entities for un-extracted memories", async () => {
+  const { service, store } = setup();
+  const mem = makeMemory(service, "记忆C", "内容C", "history");
+  const ctx = mockCtx(() => ENTITY_LLM_JSON, { provider: "p", model: "m" });
+  const result = await runSleep(
+    ctx, service,
+    baseConfig({ sleepEntityExtractionEnabled: true }),
+    ctx.logger, null, null
+  );
+  const phase = result.phases["entity-extraction"];
+  assert.equal(phase.status, "ok");
+  assert.equal(phase.extracted, 1);
+  assert.ok(store.listEntities().length > 0, "entity minted");
+  assert.ok(service.getAttrsByMemory(mem.id).length > 0, "memory now carries entity attrs");
+  store.close();
+});
+
+test("sleep: a failing extraction does not abort the batch and retries next cycle", async () => {
+  const { service, store } = setup();
+  const bad = makeMemory(service, "坏记忆", "bad 内容", "history");
+  const good = makeMemory(service, "好记忆", "good 内容", "history");
+  const ctx = mockCtx(
+    (user) => (String(user).includes("bad") ? "这不是合法JSON{{{" : ENTITY_LLM_JSON),
+    { provider: "p", model: "m" }
+  );
+  const config = baseConfig({ sleepEntityExtractionEnabled: true });
+  const first = await runSleep(ctx, service, config, ctx.logger, null, null);
+  const phase = first.phases["entity-extraction"];
+  assert.equal(phase.extracted, 1, "good memory extracted");
+  assert.equal(phase.failed, 1, "bad memory counted as failed");
+  assert.equal(phase.status, "ok", "partial success is ok");
+  assert.ok(store.listEntities().length > 0, "at least one entity minted");
+  // Good memory stamped; bad one not → second cycle retries only the bad one.
+  assert.ok(service.getById(good.id).metadata?.entity_extracted_at, "good memory stamped");
+  assert.equal(service.getById(bad.id).metadata?.entity_extracted_at, undefined, "failed memory not stamped");
+  const second = await runSleep(ctx, service, config, ctx.logger, null, null);
+  assert.equal(second.phases["entity-extraction"].extracted, 0, "bad memory still fails");
+  assert.equal(second.phases["entity-extraction"].failed, 1, "failed memory retried");
+  store.close();
+});
+
+test("sleep: metadata merge keeps unrelated fields when stamping (review #4)", async () => {
+  const { service, store } = setup();
+  const mem = makeMemory(service, "记忆M", "内容M", "history");
+  service.setMemoryMetadata(mem.id, { custom_flag: "keep-me" });
+  const ctx = mockCtx(() => ENTITY_LLM_JSON, { provider: "p", model: "m" });
+  await runSleep(ctx, service, baseConfig({ sleepEntityExtractionEnabled: true }), ctx.logger, null, null);
+  const meta = service.getById(mem.id).metadata;
+  assert.equal(meta.custom_flag, "keep-me", "pre-existing metadata not clobbered");
+  assert.ok(meta.entity_extracted_at, "stamp added alongside");
+  store.close();
+});
+
+test("sleep: pending_extracted_at is cleared on success and on failure (review #3)", async () => {
+  const { service, store } = setup();
+  const good = makeMemory(service, "好记忆", "内容G", "history");
+  const bad = makeMemory(service, "坏记忆", "bad 内容", "history");
+  const ctx = mockCtx(
+    (user) => (String(user).includes("bad") ? "不是JSON{{{" : ENTITY_LLM_JSON),
+    { provider: "p", model: "m" }
+  );
+  const config = baseConfig({ sleepEntityExtractionEnabled: true });
+  const first = await runSleep(ctx, service, config, ctx.logger, null, null);
+  const phase = first.phases["entity-extraction"];
+  assert.equal(phase.extracted, 1);
+  assert.equal(phase.failed, 1);
+  assert.equal(service.getById(good.id).metadata?.pending_extracted_at, null, "success clears pending");
+  assert.equal(service.getById(bad.id).metadata?.pending_extracted_at, null, "failure clears pending");
+  store.close();
+});
+
+test("sleep: all-failed extraction surfaces failed status through deriveStatus (review #5)", async () => {
+  const { service, store } = setup();
+  makeMemory(service, "坏记忆1", "bad 一", "history");
+  makeMemory(service, "坏记忆2", "bad 二", "history");
+  const ctx = mockCtx(() => "不是JSON{{{", { provider: "p", model: "m" });
+  const result = await runSleep(ctx, service, baseConfig({ sleepEntityExtractionEnabled: true }), ctx.logger, null, null);
+  const phase = result.phases["entity-extraction"];
+  assert.equal(phase.status, "failed", "all-failed extraction reports failed");
+  assert.equal(phase.failed, 2);
+  assert.ok(["failed", "degraded"].includes(result.status), "deriveStatus folds failed into run status");
+  store.close();
+});
+
+test("store: listForEntityExtraction pages oldest un-stamped candidates (review #2)", async () => {
+  const { service, store } = setup();
+  const a = makeMemory(service, "甲", "内容甲", "history");
+  makeMemory(service, "乙", "内容乙", "history");
+  const archived = makeMemory(service, "归档", "内容归档", "history");
+  store.setArchived(archived.id, true);
+  makeMemory(service, "摘要", "内容摘要", "summary");
+  makeMemory(service, "丙", "内容丙", "history"); // second un-stamped candidate so oldest-first has two to compare
+  service.setMemoryMetadata(a.id, { entity_extracted_at: new Date().toISOString() });
+  const list = store.listForEntityExtraction({ limit: 10, offset: 0 });
+  const titles = list.map((m) => m.title);
+  assert.ok(!titles.includes("归档"), "archived excluded");
+  assert.ok(!titles.includes("摘要"), "summary excluded");
+  assert.ok(!titles.includes("甲"), "already-stamped excluded");
+  assert.ok(titles.includes("乙"), "un-stamped included");
+  assert.ok(titles.includes("丙"), "un-stamped included");
+  assert.equal(list[0].created_at <= list[1].created_at, true, "oldest first");
+  store.close();
+});

package/dsh-mneme/test/summarize.test.js

@@ -85,6 +85,21 @@ test("turn/end event triggers summarization and stores entries", async () => {
   assert.ok(all.some((m) => m.type === "preference"));
 });
 
+test("session with only snapshotEvents() (DSH 0.1.2-rc.1) still summarizes", async () => {
+  const { events, store } = setup();
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s6",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    snapshotEvents: () => [userMessage("用快照接口提问"), { seq: 2, type: "turn/end" }]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(store.count(), 2);
+  const all = store.all();
+  assert.ok(all.some((m) => m.type === "decision"));
+  assert.ok(all.some((m) => m.type === "preference"));
+});
+
 test("skips summarization for events other than turn/end", async () => {
   const { events, store, calls } = setup();
   const handler = events.find((e) => e.name === "session/event").fn;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modusensus/dsh-mneme",
-  "version": "0.7.6",
+  "version": "0.7.8",
   "description": "Structured memory engine for DeepSeek Harness. Offline semantic search, entity-attribute-timeline, autoDream self-consolidation, and human-editable Markdown storage.",
   "license": "MIT",
   "repository": {