dsh-memsys 0.2.1 → 0.2.3

package/README.md

@@ -1,281 +1,139 @@
 # dsh-memsys
 
-**给 DeepSeek Harness 用的长期记忆插件。** 事实只追加、候选可审、判断与裁决分开、做梦独立成库、上下文按预算注入。零依赖，只用 Node 内置的 `node:sqlite`。
+DeepSeek Harness 的长期记忆插件。事实只追加，候选可审，判断与裁决分开；记忆按预算注入上下文，支持项目、惦记、梦境与检索。
 
-```bash
-node scripts/migrate.mjs --data-dir ./data     # 建库（三库：main / control / dream）
-npm test                                        # 324 项测试
-node scripts/live-check.mjs --case tools        # 真机：插件能否装进宿主、工具能否注册
-```
-
-已实测（隔离 profile，带 key）：插件加载 → 10 个 `memsys_*` 工具注册进宿主 → 模型调用 `memsys_search` 返回真实命中 → 模型调用 `memsys_record` 写入候选与记忆，`origin.author_kind=model`、会话与调用 ID 与宿主记录一致。
-
-## 安装
+零第三方运行时依赖，只使用 Node 内置的 `node:sqlite`。
 
-**已发布到 npm**：`dsh-memsys@0.1.0`（https://www.npmjs.com/package/dsh-memsys）。
+## 特性
 
-装进一个**独立 profile**（不要直接装进你日常用的那个）：
+- **可审写入**：模型只能提交候选；记忆由候选提升产生，不能直接落事实。
+- **三库分离**：主库（事实/候选/记忆/证据/关系）、控制库（操作/尝试/编译/快照/容量）、梦库。
+- **可靠提交**：预扣、写后读回、最多一次即时补写、连续失败冻结、跨重启恢复。
+- **按预算注入**：支持 full / compressed / grouped / protected_overflow 四种交付级别，快照分页可续。
+- **检索与项目**：按关键词、场景、主题、时间检索；项目概览与版本；待确认惦记的审核分区。
+- **模块开关**：context / read / write / dream / projects / due / feed 七项独立开关。
+- **可选 Web UI**：左侧栏「记忆」面板、设置页模块开关；无 Web 服务时自动降级。
 
-```bash
-dsh --profile memsys headless --from-default-profile --dump-config   # 初始化隔离 profile
-dsh plugin --profile memsys add dsh-memsys                            # 从 npm 装
-```
+## 环境要求
 
-或者不依赖 npm，从源码装：
+- Node.js >= 22.13
+- DeepSeek Harness 0.2.x
+- 无第三方运行时依赖
 
-```bash
-git clone https://github.com/tok-ryan/dsh-memsys.git dsh-memsys
-cd dsh-memsys
-npm test                    # 先跑一遍，确认本地环境能过（Node >= 22.13）
-```
+## 安装
 
 ```bash
-dsh plugin --profile memsys add "file:///全/路径/dsh-memsys"          # 按实际路径改
+dsh plugin --profile <profile> add dsh-memsys
 ```
 
-`file:///` 后面是**绝对路径、正斜杠**。Windows 上形如 `file:///C:/Users/you/dsh-memsys`。
+建议使用独立 profile，不要直接装进日常使用的 profile。
 
-**不要用 junction / 符号链接把本仓库链进 profile**：重建 profile 时递归删除会顺着链接把源码删掉（我们踩过，见 `docs/report-4.md` 的事故记录）。要装就先复制到临时目录再装。
-
-装完自检：
+从源码安装时，先把仓库复制到临时目录再安装，不要在 profile 里使用 junction 或符号链接。
 
 ```bash
-dsh plugin --profile memsys --dump-config | grep dsh-memsys   # 应该能看到插件条目
-node scripts/live-check.mjs --case tools --profile memsys      # 真机：插件加载 + 工具注册
+dsh plugin --profile <profile> add "file:///C:/path/to/dsh-memsys"
 ```
 
-移除：`dsh plugin --profile memsys remove dsh-memsys`。
-
-## 模块与分层
-
-| 目录 | 职责 |
-|---|---|
-| `src/storage/` | 三库连接、迁移（SQL）、只追加触发器、repo |
-| `src/control/` | 控制账：reserve / attempt / 精确读回 / 三败冻结 / 恢复 / 容量账 |
-| `src/write/` | 观察 → 候选 → 提升六步、裁决与回执、项目、惦记、自述 |
-| `src/context/` | 选择、排序、预算、编译（full/compressed/grouped）、快照、交付回执 |
-| `src/read/` | 取回：get / search / review / self / project / dream / activity |
-| `src/tools/` | 工具 schema 与 handler；`src/runtime/` 负责宿主注册与身份 |
-| `src/dream/` | 梦库：命题、确认链、浮现、整理 |
-| `src/import/` | 旧内容导入、门牌回填、回退核验 |
-| `src/feed/` | 三闸筛选（相关 → 细节 → 时间） |
-| `src/gates/` | 验收边界，可失败 |
-
-**设计原则**：事实只追加；当前状态是可重建投影；模型只能提交候选，不能直接落事实；一切写后读回按固化预期比对，不是"行还在就算成功"。
-
-## 界面（0.2.0 起）
-
-装上之后 Web GUI 里会多三样东西，都来自同一个浏览器半 `client.js`：
-
-- **左侧栏「🐳 记忆」**：点开是一块面板——记忆条数 / 候选条数 / 待确认惦记数，加最近 5 条记忆正文（超长截断）
-- **设置 →「记忆系统」**：`auto_inject` 开关 + 当前数据目录；开关改完**立即生效**（重挂/撤下 system prompt 里的记忆段），刷新后仍在
-- 面板与设置页共用数据口 `/dsh-memsys/api/*`（loopback + 同源校验；跨源 403）
-
-**设置优先级**：`<data_dir>/ui-config.json`（存在且合法）> profile 的 `config` > 默认全开。
-`/api/summary` 会返回 `modules` / `modules_source`，告诉你每个开关的当前值和来源（`ui-config` / `profile` / `default`）。
-
-**注意生效时机**：自动注入、写入工具**改完立即生效**；读取工具 / 做梦 / 项目 / 待确认惦记 / 信息流是**下次启动生效**（工具在启动时一次性注册，宿主没有注销接口）。
-
-**headless 不受影响**：没有 `webServer` 时那段注册不激活，浏览器半也不加载。
-
-## 状态（0.2.1）
-
-- **读**：真机 `dispatch=ok`，`direct_hit_count: 2` 返回真实命中
-- **写**：真机 `record=ok`，库内落 candidate + memory，`origin.author_kind=model`、`call_id` 与宿主记录一致
-- **注入**：`compileRound` 已接进运行时，section 文本是**当轮编译出来的记忆目录**（`text` 为函数，每步 `assemble()` 重取）；无 tokenizer/H 时退回 tools-only，不假装投递（`delivery=unknown`）
-- **界面**：左侧栏「记忆」入口 + 面板（三数字 + 最近 5 条）+ 设置页七行模块开关
-- **测试**：356 项全绿
-
-**仍不达标**：`L6` 只核到内容 hash 与关联，**没有逐项重放 relations 内容**；真实旧库尚未导入；生产 cutover 未跑；`feed` 生产 provider 未接。见文末"已知边界"。
-
-MIT License。
-
----
-
-_以下为原始施工期文档（安装、默认行为、边界），保留以便对照：_
-
-# dsh-memsys · 第一批（存储 / 写入 / 可靠提交 / 注入 / 取回）
-
-本包是 DSH 的长期记忆器官第一批实现。行为规范只有一份：`whale-unify/memsys-design-v0.38.md`；本文件只讲**怎么装、怎么跑、默认行为是什么、哪些边界还没闭合**。
+安装后自检：
 
-## 一、这一批做了什么
-
-- 三库底座：主库（事实/候选/记忆/证据/事件）、控制账（操作、尝试、编译、快照、容量）、梦库（仅 schema 占位）。
-- 写入三段：观察（输入原话先落库并读回）→ 候选（capture / 工具候选）→ 提升六步（memories / timeline / pointers / 证据 / 候选状态 / promote 事件，同一事务）。
-- 可靠提交：控制账预扣尝试、写后读回三态（found / missing / unknown）、最多一次即时补写、失败三次冻结、跨重启保留、操作者可解冻。
-- 注入器官：按已验证钩子 `ctx.inject(['systemPrompt'], …)` 注册一个段（`memsys:context`，order=500），全集 S、排序、字符/字节/token 分账、full / compressed / grouped / protected_overflow 四档、分组三件套、快照分页、投递回执与曝光。
-- 取回工具：`memsys_get / memsys_search / memsys_review_get / memsys_context_get` 的离线处理器，`memsys_record` 写入处理器。
-
-**不包含**：做梦、self note 工具、judgments、projects、旧数据迁移、feed、主人专有动作入口。
-
-## 二、环境要求
-
-- Node >= 22.13（本机实测 v24.19.0）。
-- 只用内置 `node:sqlite`，**零第三方依赖**，不编译原生模块。
-- 不需要 API key、不需要网络；`live-check` 的模型回合由人另外执行。
-
-## 三、迁移与自检
-
-```powershell
-# 迁移并打印固定验收行
-node whale-unify/memsys/scripts/migrate.mjs --data-dir whale-unify/_build/test-data/m1
-# 期望：MIGRATIONS_OK main=3 control=2 dream=1
-
-# 三库完整性
-node whale-unify/memsys/scripts/check-db.mjs --data-dir whale-unify/_build/test-data/m1
-# 期望：每库 integrity_check=ok、foreign_key_check=0；migrations 3/2/1
-```
-
-- 生产默认目录是 `~/.dsh/memsys/`（由受控启动配置决定，模型不能选库或目录）。
-- 验收/测试必须显式传 `--data-dir`，不要写生产库。
-- 迁移按库各自事务执行；已应用脚本的哈希不一致会拒绝启动；库版本高于当前代码只读报错。
-
-## 四、测试与门禁
-
-```powershell
-npm --prefix whale-unify/memsys test        # 全部离线套件，当前 118 条
-node whale-unify/memsys/scripts/build.mjs  # 语法/入口/bundle 检查 → BUILD_OK
-node whale-unify/memsys/scripts/check-bom.mjs  # UTF-8 与 BOM 检查 → UTF8_OK BOM=0
-```
-
-单套件示例：
-
-```powershell
-node --test whale-unify/memsys/test/m1-storage.test.mjs
-node --test whale-unify/memsys/test/m2-write.test.mjs
-node --test whale-unify/memsys/test/m3-reliable.test.mjs
-node --test whale-unify/memsys/test/m4-context.test.mjs
-node --test whale-unify/memsys/test/m5-tools.test.mjs whale-unify/memsys/test/e2e.test.mjs
+```bash
+dsh --profile <profile> --dump-config
 ```
 
-## 五、装进 DSH（独立 profile）
-
-> **禁止把工作区目录以 junction / 符号链接 / 硬链接的方式链进 profile。** 重建 profile 时递归删除会跟随链接，把源码一起删掉（本项目真出过一次事故）。要装就复制。
+配置中应出现 `dsh-memsys`。
 
-```powershell
-# 1) 复制到 ASCII 临时目录（不要直接 add 工作区路径）
-$stage = Join-Path $env:TEMP "dsh-memsys-pkg"
-Remove-Item $stage -Recurse -Force -ErrorAction SilentlyContinue
-New-Item -ItemType Directory $stage | Out-Null
-Copy-Item whale-unify/memsys\package.json, whale-unify/memsys\index.mjs, whale-unify/memsys\cordis.patch.yml $stage
-Copy-Item whale-unify/memsys\src $stage\src -Recurse
+## 配置
 
-# 2) 建独立 profile（不要碰 desktop）并安装
-dsh --profile memsys-plan1-probe --from-default-profile headless --dump-config
-dsh plugin --profile memsys-plan1-probe add $stage
+在 profile 的 patch 中配置：
 
-# 3) 验证 bundle 条目已组合
-dsh --profile memsys-plan1-probe --dump-config    # 应出现 id: memsys / name: dsh-memsys
-
-# 4) 收尾：卸掉插件，删临时副本
-dsh plugin --profile memsys-plan1-probe remove dsh-memsys
-Remove-Item $stage -Recurse -Force
+```yaml
+- id: memsys
+  config:
+    data_dir: C:/path/to/memsys-data
+    modules:
+      context: true
+      read: true
+      write: true
+      dream: true
+      projects: true
+      due: true
+      feed: true
 ```
 
-若某次 profile 里已有 `node_modules/memsys` 链接，**先按目录项删除**（`[System.IO.Directory]::Delete($link)` 或 `rmdir`），确认目标未被动过，再重建 profile。
+- `data_dir`：三库与运行数据目录；未配置时插件不创建数据库。
+- `modules`：缺省为开启。安装后的默认行为是自动注入关闭（`context: false`），其余六项开启；可在设置页或 `ui-config.json` 中覆盖。
+- 兼容旧配置：只有 `auto_inject: true` 时等价于 `modules.context: true`。
 
-## 六、真机探针（无 key）
+配置优先级：
 
-```powershell
-node whale-unify/memsys/scripts/live-check.mjs --case inject --profile memsys-plan1-probe
-# 期望：LIVE_CHECK_OK case=inject plugin=loaded section=memsys:context order=500 auto_inject=false delivery=unknown
-```
+1. `<data_dir>/ui-config.json`
+2. profile 的 `config`
+3. 默认值
 
-它在**不调用模型**的前提下证明：插件装载成功、bundle 条目已组合、启动时 `ctx.inject(['systemPrompt'])` 回调执行并注册了 `memsys:context / order=500`（插件会写一个临时标记文件）。启动最后会因缺少 key 停在 `MISSING_CREDENTIAL`，这是预期行为。
+## 工具
 
-**"段真的进了 system prompt" 需要一次真模型回合来核对 `system/message`，这一步不由本脚本承担。** 证据写在 `whale-unify/_build/artifacts/live-check-inject.json`。
-
-## 七、默认行为：auto_inject = false（tools-only 档）
-
-| 配置 | 行为 |
+| 工具 | 用途 |
 |---|---|
-| `auto_inject: false`（默认） | **不注册** systemPrompt 段；不承诺逐轮交付；`delivery=unknown`；只能用取回工具主动查询 |
-| `diagnostic_section: true`（仅探针） | 注册段（`memsys:context`，order=500），正文是诊断占位，**不是**真实记忆交付 |
-| `auto_inject: true` 且预算/回执未验证 | 仍按 tools-only 处理：`compileRound` 没有 tokenizer 或宿主 H 时返回 `mode=tools-only`、`section=null` |
-
-为什么默认关：宿主 tokenizer、真实上下文预算 H、独立投递回执三项都还没在真实宿主上验证。缺任何一项就不许声称"每轮全量交付"。
+| `memsys_get` | 按 id 读取记忆、证据、时间线，支持历史视图 |
+| `memsys_search` | 关键词 / 场景 / 主题 / 时间检索 |
+| `memsys_review_get` | 候选、待审、惦记历史、已确认梦境 |
+| `memsys_context_get` | 展开冻结上下文快照中的一个分组 |
+| `memsys_project_get` | 项目概览与版本历史 |
+| `memsys_self_get` | 自述、判断、推测 |
+| `memsys_record` | 写入候选、判断、自述、项目更新、惦记操作提案 |
+| `memsys_dream_record` | 记录梦境与命题 |
+| `memsys_organize` | 精确合并或取代提案 |
+| `memsys_feed` | 信息流筛选（需要对应 provider） |
 
-## 八、编译产物怎么读
+关闭模块时：
 
-`compileRound(...)` 的返回（节选）：
+- `read: false`：不注册读取类工具。
+- `dream: false`：不注册梦境工具，梦不浮现。
+- `projects: false`：不注册项目读取工具。
+- `feed: false`：不注册信息流工具。
+- `write: false`：写工具保留注册，但调用返回 `module_disabled`。
 
-- `delivery_level`：`full`（完整目录在软预算与 H 内）/ `compressed`（摘要按 40→20→8 码点压缩）/ `grouped`（逐条装不下，只给分组目录）/ `protected_overflow`（连固定层 + 分组头都超过 H）。
-- `section`：`{ name: 'memsys:context', order: 500, text, payload_hash }`。
-- `hard` / `soft`：分别记条数、UTF-8 字节、token；**字符 / 字节 / token 三列分开，不互相顶替**。
-- `groups[]`：每组给 `group_id`、中文组名、`total_count`、`deferred_count`，以及可执行参数
-  `memsys_context_get(snapshot_revision=…, group_id=…, cursor=null, max_chars=8000)`。
-  正文里不会出现"另有 N 条"这种不可执行的计数。
-- `delivery`：默认 `unknown`；只有收到满足"空闲集合相等 + payload hash 匹配"的回执才会 `confirmed`，部分回执是 `incomplete`。
-- 快照：`snapshot_revision` 指向控制账里的持久快照，分组页游标绑定"快照 + 组"；快照过期返回 `stale_cursor` 并给新报告入口，不会把新版数据拼进旧页。
+## Web UI
 
-## 九、工具面
+安装后，Web GUI 会增加：
 
-离线处理器（测试与 tools-only 档都走它）：
+- **左侧栏「记忆」**：记忆条数、候选条数、待确认惦记数，以及最近 5 条记忆。
+- **设置 →「记忆系统」**：模块开关与当前数据目录。
+- **数据接口**：`/dsh-memsys/api/summary` 与 `/dsh-memsys/api/config`，仅接受 loopback 与同源请求。
 
-```js
-import { createReadHandler } from './src/tools/read.mjs';
-const tools = createReadHandler({ main, control, clock });
-tools.get({ ids: ['mem_…'], view: 'current', include_evidence: true, max_chars: 8000 });
-tools.search({ keywords: '葱', scene: 'life', topic_key: 'tk:…', time_range: { start, end } });
-tools.review({ kind: 'candidate' });      // 或 kind: 'pending' / 'due-history'
-tools.context({ snapshot_revision, group_id, cursor: null, max_chars: 8000 });
-tools.touch({ roundId, memoryId, kind: 'lookup' }); // 只对真实读取记 lookup
-```
-
-- `memsys_get`：1–10 个唯一 id；`missing_ids` 与读取错误分开；超长正文按码点分片，`next_cursor` 续页，拼回后与原文逐字一致。
-- `memsys_search`：关键词/场景/主题/时间范围过滤；空命中是 `status=ok`，不是错误；`graph` 参数返回 `unsupported_feature=graph`（第一批没有骨架）。
-- `memsys_review_get`：候选/权限提案/due-history，给期限、默认出路、可用操作；这里的文本是审核材料，不是事实正文。
-- `memsys_context_get`：只读持久快照分组页，不扩大快照场景。
-- `lookup` 与 `used` 分开：只有真实读取加 `uses`，同轮同条只加一次；`used` / 主人提及只刷新 `last_touched_at`。
-
-**宿主工具注册 API 尚未验证**：`registerTools(...)` 在没有传入真实 `register` 函数时抛 `tool_registration_unverified`，能力状态保持 `unknown`。不要在这之前声称工具已在线可用。
-
-## 十、数据、备份与恢复
+没有 `webServer` 服务时，host 半不激活 UI 路由，浏览器半也不会加载；headless profile 不受影响。
 
-- 位置：`~/.dsh/memsys/{memsys.db, control.db, dreams.db}`；连接固定 `journal_mode=WAL`、`foreign_keys=ON`、`synchronous=FULL`、`busy_timeout=5000`。
-- 只追加：observations / evidence / relations / origins / operation_attempts / control_events 由触发器拒改拒删；candidates 只许 4 列、memories 只许 3 列事件投影。
-- 备份：`node:sqlite` 没有 `db.backup()`，统一用 `VACUUM INTO` 做一致性快照（包含已提交 WAL 内容），不要直接复制 db/wal/shm。
-- 检查点：`node scripts/checkpoint.mjs --label M5 --data-dir <dir>` 同时写源码副本（`_build/backup/<批次>/`）与三库备份（`<data-dir>/backup/<批次>/`）。
-- 写后读回：业务提交后必须精确读回；`found / missing / unknown` 三态分明，`unknown` 不许当 `missing`。
-- 冻结：同一对象连续三次失败 → `frozen=true`，第四次业务写为 0；重启不归零；冻结后探测到数据存在只记 `reconciliation`，不自动解冻。解冻只能由本地操作者指定 `object_key`、原因与新 generation。
-- 梦库第一批只有 `schema_migrations` 和占位标记，没有任何梦内容表。
+## 数据与备份
 
-## 十一、真机验证结果（2026-11-03）
+- `memsys.db`：业务事实与证据。
+- `control.db`：操作账、编译快照、容量与恢复。
+- `dreams.db`：梦境库。
+- 备份使用 SQLite 一致性备份；恢复校验会比较三库版本与关键表内容，不一致时失败。
 
-| 项 | 命令 | 结果 |
-|---|---|---|
-| 工具注册 | `node scripts/live-check.mjs --case tools` | `LIVE_CHECK_OK registration=registered registered=10 schemas=35 get=true` |
-| 工具调度 | `node scripts/live-check.mjs --case dispatch`（带 key） | `LIVE_CHECK_OK dispatch=ok`；`tool/result` 里 `direct_hit_count: 2`（命中「葱是绿的」「葱可以吃」），`evidence_mean: 0.14` |
-| 注入段 | `node scripts/live-check.mjs --case inject` | `LIVE_CHECK_OK section=memsys:context order=500 auto_inject=false delivery=unknown` |
+## 开发
 
-证据：`_build/artifacts/live-check-{tools,dispatch,inject}.json`。
-`live-check` 每次会先删 profile 内插件、清空 `%TEMP%` 暂存目录再复制，并记 `stage_hash`；出现 `stale_stage` 说明跑的不是当前代码。
+```bash
+npm test
+npm run build
+```
 
-## 十二、已知边界（不许当成已闭合）
+测试覆盖存储、写入、可靠提交、上下文编译、检索、项目、惦记、梦、导入、回退与模块闸门。
 
-写完功能不等于达标。下面 10 条是两轮 Codex 复核后**仍未满足设计稿**的：
+## 设计边界
 
-1. **恢复不按操作类型核完整预期结果**（L1）：due/promote 的完整结果、事件与证据集合没进读回判据
-2. **批准取得写锁后未重验基版本**（E2）：内容可能在验证与写入之间变化
-3. **编译没走三败控制**（E8）：compile 直写控制账，没有 reserve/complete
-4. **快照不是内容寻址**（C3）：靠 section hash 拒绝同 ID 覆盖；未用真实重复编译测混版
-5. **空分组回执边界**（C1）：只有组头、无实际 memory 时的确认语义未测死
-6. **证据原文无分片续页**（C4）：`observation_text` 只截断
-7. **回退不重放关系内容**（B3）：只核行存在与关联，不核 relations 内容/hash
-8. **合并只保 `due_at`**（B1）：候选层没有 `due_state`/`done`
-9. **门牌回填靠事件自证**（B2）：不重读源文件；图只核基本字段
-10. **写入类工具仍不可用**：`memsys_record`/`dream_record`/`organize` 返回 `runtime_identity_unavailable`
+- 模型不能直接写记忆，只能提交候选；确认与裁决属于主人侧动作。
+- 没有宿主回执时，交付状态保持 `unknown`，不假装已投递。
+- 证据必须能回到原始观察；来源不可读或字节范围变化时，门牌回填拒绝写入。
+- 自动注入是显式开关；关闭时只保留普通工具读取。
 
-另外：`feed` 生产 provider 未接（`integration_pending`）；真实旧库尚未导入，迁移只在夹具上验过。
+## 已知限制
 
+- `L6` 回退核验只到内容 hash 与关联，**未逐项重放 relations 内容**。
+- 真实旧库尚未导入；生产 cutover 未跑。
+- `feed` 的生产 provider 未接。
+- 界面只在开发者本机目测过一次，未做多分辨率与暗色之外的主题验证。
+- 自动注入默认关闭（`context: false`），需要手动开启。
 
-## 十二、三十秒自检
+## License
 
-```powershell
-node --version                                   # >= 22.13
-node whale-unify/memsys/scripts/build.mjs        # BUILD_OK
-node whale-unify/memsys/scripts/check-bom.mjs    # UTF8_OK BOM=0
-npm --prefix whale-unify/memsys test             # 118/118
-node whale-unify/memsys/scripts/migrate.mjs --data-dir whale-unify/_build/test-data/m5
-node whale-unify/memsys/scripts/check-db.mjs --data-dir whale-unify/_build/test-data/m5
-```
+MIT

package/client.js

@@ -6,6 +6,7 @@ window.__ModuleLoader__.load({
     const NS = 'dsh-memsys';
     const API = '/dsh-memsys/api/summary';
     const CONFIG = '/dsh-memsys/api/config';
+    const SEARCH = '/dsh-memsys/api/search';
 
     function useSummary() {
       const [state, setState] = React.useState(null);
@@ -27,19 +28,155 @@ window.__ModuleLoader__.load({
       return [state, setState];
     }
 
+    // Pure CSS/DOM "memory balls on a shelf". No 3D library, no build step,
+    // no external resource: gradient + inset shadow + one float keyframe.
+    const BALL_CSS = [
+      '@keyframes msFloat{0%,100%{transform:translateY(0)}50%{transform:translateY(-3px)}}',
+      '.ms-panel{padding:16px;line-height:1.7}',
+      '.ms-counts{margin:0 0 12px;opacity:.85}',
+      '.ms-shelf{display:flex;gap:16px;align-items:flex-end;padding:12px 16px 8px;margin:0 0 10px;border-radius:12px;',
+      'background:linear-gradient(180deg,rgba(127,127,127,.10),rgba(127,127,127,.03));',
+      'box-shadow:inset 0 -1px 0 rgba(127,127,127,.28)}',
+      '.ms-ball{width:44px;height:44px;border-radius:50%;border:0;padding:0;cursor:pointer;position:relative;',
+      'background:radial-gradient(circle at 32% 27%,rgba(255,255,255,.95),rgba(255,255,255,.28) 16%,var(--ms-c) 60%,rgba(0,0,0,.45) 100%);',
+      'box-shadow:inset -6px -8px 14px rgba(0,0,0,.30),inset 6px 6px 12px rgba(255,255,255,.22),0 4px 10px rgba(0,0,0,.18);',
+      'animation:msFloat 5s ease-in-out infinite;transition:transform .15s ease,box-shadow .15s ease}',
+      '.ms-ball:hover,.ms-ball:focus-visible{transform:scale(1.06);',
+      'box-shadow:inset -6px -8px 14px rgba(0,0,0,.30),inset 6px 6px 12px rgba(255,255,255,.22),0 0 18px 4px var(--ms-glow);outline:none}',
+      '.ms-ball[aria-pressed="true"]{transform:scale(1.06);box-shadow:0 0 18px 4px var(--ms-glow)}',
+      '.ms-empty{width:44px;height:44px;border-radius:50%;border:1px dashed rgba(127,127,127,.35);background:rgba(127,127,127,.05)}',
+      '.ms-card{margin-top:10px;padding:12px 14px;border-radius:10px;background:rgba(127,127,127,.08);font-size:.95em}',
+      '.ms-hint{opacity:.75;margin:6px 0 0}',
+      '.ms-search{width:100%;box-sizing:border-box;padding:7px 10px;margin:0 0 12px;border-radius:8px;',
+      'border:1px solid rgba(127,127,127,.35);background:rgba(127,127,127,.06);color:inherit;font:inherit}',
+      '.ms-row{display:block;width:100%;text-align:left;padding:8px 10px;margin:0 0 6px;border-radius:8px;cursor:pointer;',
+      'border:1px solid transparent;background:rgba(127,127,127,.06);color:inherit;font:inherit}',
+      '.ms-row:hover,.ms-row:focus-visible{border-color:rgba(63,167,255,.55);outline:none}',
+      '.ms-kind{opacity:.65;margin-right:6px;font-size:.9em}',
+      '.ms-muted{opacity:.65}',
+      '@media (prefers-reduced-motion:reduce){.ms-ball{animation:none}}',
+    ].join('');
+    const BALL_COLORS = ['#3fa7ff', '#5b8cff', '#7a6bff', '#8f5bd8', '#8450a8'];
+    const BALL_GLOWS = [
+      'rgba(63,167,255,.45)',
+      'rgba(91,140,255,.45)',
+      'rgba(122,107,255,.45)',
+      'rgba(143,91,216,.45)',
+      'rgba(132,80,168,.45)',
+    ];
+    const EMPTY_SLOTS = 5;
+    const CARD_TEXT_LIMIT = 120;
+
+    function SearchResults({ query, onOpen, openId }) {
+      const [result, setResult] = React.useState(null);
+      const [failed, setFailed] = React.useState(false);
+      React.useEffect(() => {
+        if (!query) return undefined;
+        let alive = true;
+        let timer = null;
+        const run = () => {
+          fetch(SEARCH + '?q=' + encodeURIComponent(query))
+            .then((response) => (response.ok ? response.json() : Promise.reject(new Error(String(response.status)))))
+            .then((data) => {
+              if (!alive) return;
+              setFailed(false);
+              setResult(Array.isArray(data?.items) ? data.items : []);
+            })
+            .catch(() => {
+              if (alive) setFailed(true);
+            });
+        };
+        timer = setTimeout(run, 250);
+        return () => {
+          alive = false;
+          clearTimeout(timer);
+        };
+      }, [query]);
+      if (failed) return h('p', { className: 'ms-muted' }, '搜索不可用');
+      if (result === null) return h('p', { className: 'ms-muted' }, '搜索中…');
+      if (result.length === 0) return h('p', { className: 'ms-muted' }, '没找到匹配的记忆');
+      return h('div', { role: 'list', 'aria-label': '搜索结果' },
+        result.map((item) => {
+          const open = openId === item.id;
+          const body = Array.from(String(item.text ?? '')).slice(0, CARD_TEXT_LIMIT).join('');
+          return h('button', {
+            key: item.id,
+            type: 'button',
+            role: 'listitem',
+            className: 'ms-row',
+            'aria-expanded': open,
+            onClick: () => onOpen(open ? null : item.id),
+          },
+          h('span', { className: 'ms-kind' }, '[' + (item.kind ?? 'memory') + ']'),
+          h('span', null, open ? body : Array.from(body).slice(0, 40).join('') + (body.length > 40 ? '…' : '')),
+          );
+        }));
+    }
+
     function MemoryPanel() {
       const [state] = useSummary();
-      if (!state) return h('p', { style: { padding: 16 } }, '读取记忆…');
-      if (state.error) return h('p', { style: { padding: 16 } }, '暂时读不到记忆数据。');
+      const [selectedId, setSelectedId] = React.useState(null);
+      const [query, setQuery] = React.useState('');
+      const [openResultId, setOpenResultId] = React.useState(null);
+      if (!state) return h('p', { className: 'ms-panel' }, '读取记忆…');
+      if (state.error) return h('p', { className: 'ms-panel' }, '暂时读不到记忆数据。');
+      const recent = state.recent ?? [];
+      const selected = recent.find((memory) => memory.id === selectedId) ?? null;
+      // Pad with ghost slots so an almost-empty shelf keeps its shape.
+      const shelf = [];
+      for (let index = 0; index < Math.max(recent.length, EMPTY_SLOTS); index += 1) shelf.push(recent[index] ?? null);
       return h(
         'div',
-        { style: { padding: 16, lineHeight: 1.7 } },
+        { className: 'ms-panel' },
+        h('style', { dangerouslySetInnerHTML: { __html: BALL_CSS } }),
         h('h2', { style: { margin: '0 0 8px' } }, '记忆'),
-        h('p', null, `记忆 ${state.memories} 条 · 候选 ${state.candidates} 条 · 待确认惦记 ${state.pending_due} 条`),
-        h('h3', { style: { margin: '16px 0 6px' } }, '最近 5 条'),
-        state.recent.length === 0
-          ? h('p', null, '还没有记忆。')
-          : h('ul', null, state.recent.map((memory) => h('li', { key: memory.id }, memory.text))),
+        h('p', { className: 'ms-counts' },
+          `记忆 ${state.memories} 条 · 候选 ${state.candidates} 条 · 待确认惦记 ${state.pending_due} 条`),
+        h('input', {
+          className: 'ms-search',
+          type: 'search',
+          value: query,
+          placeholder: '搜记忆…',
+          'aria-label': '搜记忆',
+          onChange: (event) => setQuery(event.target.value),
+          onKeyDown: (event) => {
+            // Enter searches immediately; typing waits for the 250ms debounce.
+            if (event.key === 'Enter') setQuery(event.currentTarget.value);
+          },
+        }),
+        query
+          ? h(SearchResults, { query, openId: openResultId, onOpen: setOpenResultId })
+          : h('div', { className: 'ms-shelf', role: 'list', 'aria-label': '最近的记忆' },
+          shelf.map((memory, index) => memory === null
+            ? h('span', { key: `empty-${index}`, className: 'ms-empty', 'aria-hidden': true })
+            : h('button', {
+              key: memory.id,
+              type: 'button',
+              role: 'listitem',
+              className: 'ms-ball',
+              'aria-pressed': selectedId === memory.id,
+              'aria-label': memory.text,
+              title: memory.text,
+              style: {
+                '--ms-c': BALL_COLORS[Math.min(index, BALL_COLORS.length - 1)],
+                '--ms-glow': BALL_GLOWS[Math.min(index, BALL_GLOWS.length - 1)],
+                animationDelay: `${index * 0.35}s`,
+                width: `${44 - Math.min(index, 3) * 2}px`,
+                height: `${44 - Math.min(index, 3) * 2}px`,
+              },
+              onClick: () => setSelectedId(selectedId === memory.id ? null : memory.id),
+            })),
+        ),
+        query
+          ? null
+          : h('p', { className: 'ms-hint' },
+            recent.length === 0
+              ? '还没有记忆。去跟模型说一句「记住：…」吧'
+              : '点亮一颗球，看看它装的是什么。'),
+        !query && selected
+          ? h('div', { className: 'ms-card', key: selected.id },
+            Array.from(selected.text).slice(0, CARD_TEXT_LIMIT).join(''))
+          : null,
       );
     }
 
@@ -115,6 +252,11 @@ window.__ModuleLoader__.load({
         h('p', { style: { opacity: 0.75, margin: '10px 0 0' } }, `数据目录：${state?.data_dir ?? '未配置'}`),
         h('p', { style: { opacity: 0.75, margin: '4px 0 0' } },
           `当前生效值来源：${SOURCE_LABEL[state?.modules_source] ?? state?.modules_source ?? '未知'}`),
+        // A switch that says "on" while the injector runs on tools-only text is a lie.
+        state?.inject && state.inject.level === 'unavailable'
+          ? h('p', { style: { margin: '4px 0 0', color: '#c46a00' } },
+            `自动注入没跑起来（${state.inject.reason ?? 'unknown'}）`)
+          : null,
         note ? h('p', { style: { opacity: 0.75, margin: '4px 0 0' } }, note) : null,
       );
     }

package/index.mjs

@@ -12,10 +12,20 @@ import { createFeedHandler } from './src/tools/feed.mjs';
 import { createSelfHandler } from './src/tools/self.mjs';
 import { createRecordHandler } from './src/tools/record.mjs';
 import { runtimeFromExec } from './src/runtime/identity.mjs';
-import { createSummaryHandler } from './src/runtime/summary.mjs';
+import { createSearchHandler, createSummaryHandler } from './src/runtime/summary.mjs';
 import { mergeModules, resolveModulesDetail, writeUiConfig } from './src/runtime/ui-config.mjs';
 import { createRoundInjector } from './src/runtime/inject-round.mjs';
+import { createMemSysService, provideMemSysService } from './src/runtime/service.mjs';
 import { compileRound } from './src/context/compile.mjs';
+import { conservativeTokens } from './src/context/budget.mjs';
+
+/**
+ * Conservative host budget for the round injector: `conservativeTokens` counts
+ * ceil(codepoints / 2), so 900 tokens ≈ 1800 characters of section text — enough
+ * for a small directory, small enough that injection never crowds out the task.
+ * A host that knows its real budget overrides this with `config.H`.
+ */
+const DEFAULT_HOST_BUDGET_TOKENS = 900;
 
 export const name = 'dsh-memsys';
 /** tools is a real host service; static inject is the verified registration path. */
@@ -52,6 +62,9 @@ function createUiState(config = {}, logger = console) {
       Object.assign(modules, written.modules);
       source = 'ui-config';
     },
+    // Overridden by `apply` once the injector exists; the settings page reads it
+    // through /api/summary so a dead injector is visible instead of silent.
+    injectStatus: () => ({ level: 'unavailable', reason: 'not_started' }),
     sync: () => {},
   };
 }
@@ -71,10 +84,11 @@ function createHostHandlers(config = {}, ctx = null, ui = null) {
     apply() {},
     sync: () => {},
   };
+  const uiSearch = createSearchHandler({ main: () => db().main, clock: systemClock });
   const uiSummary = createSummaryHandler({
     main: () => db().main,
     dataDir,
-    getConfig: () => ({ modules: uiState.modules, source: uiState.source }),
+    getConfig: () => ({ modules: uiState.modules, source: uiState.source, inject: uiState.injectStatus() }),
     onConfig: (patch) => {
       if (!dataDir) {
         const err = new Error('data_dir_missing');
@@ -136,6 +150,9 @@ function createHostHandlers(config = {}, ctx = null, ui = null) {
     memsys_self_get: (args) => createSelfHandler({ main: db().main, clock: systemClock }).get(args),
     memsys_feed: (args) => createFeedHandler({ clock: systemClock }).feed(args),
     memsys_ui_summary: (req, res) => uiSummary(req, res),
+    memsys_ui_search: (req, res) => uiSearch(req, res),
+    // Cross-plugin surface: `ctx.provide('memsys', …)` exposes this instance.
+    memsys_service: () => createMemSysService({ main: db().main, control: db().control, clock: systemClock }),
     memsys_record: (args, exec) => {
       const identity = runtimeFromExec({ exec, ctx, tool: 'record', args });
       if (!identity.ok) return { status: 'error', code: identity.code, ...identity };
@@ -167,6 +184,17 @@ export async function apply(ctx, config = {}) {
   const handlers = createHostHandlers(config, ctx, ui);
   const registration = await registerHostTools({ ctx, handlers, modules: ui.modules });
 
+  // Optional cross-plugin service: other plugins reach memsys through
+  // `ctx.get('memsys')`. Registration needs `ctx.provide`; a profile (or a fake
+  // harness in tests) without it simply keeps the service unprovided.
+  if (typeof ctx?.provide === 'function' && typeof handlers.memsys_service === 'function') {
+    try {
+      provideMemSysService(ctx, handlers.memsys_service());
+    } catch {
+      // no data dir yet, or the host refused the registration: tools still work
+    }
+  }
+
   // The round injector owns the session/turn subscription; the section only
   // reads its current text. Verified empirically: a section's `text` function is
   // re-evaluated on every `systemPrompt.assemble()` (once per model step), so no
@@ -184,8 +212,11 @@ export async function apply(ctx, config = {}) {
         dataDir: ui.dataDir,
         modules: ui.modules,
         compileRound,
-        tokenizer: config.tokenizer ?? null,
-        H: config.H ?? null,
+        // A profile patch cannot carry a function or a host number, so both
+        // default anyway: without them compileRound degrades to tools-only and
+        // the section becomes an empty shell that never injects a memory.
+        tokenizer: config.tokenizer ?? conservativeTokens,
+        H: config.H ?? DEFAULT_HOST_BUDGET_TOKENS,
         mode: config.mode ?? 'work',
       });
       try {
@@ -195,6 +226,12 @@ export async function apply(ctx, config = {}) {
       }
     }
   };
+  ui.injectStatus = () => {
+    if (ui.modules.context === false) return { level: 'disabled', reason: 'context_off' };
+    if (!injector) return { level: 'unavailable', reason: ui.dataDir ? 'injector_failed' : 'data_dir_missing' };
+    const level = injector.current?.().delivery_level ?? 'unavailable';
+    return { level, reason: level === 'unavailable' ? 'compile_unavailable' : null };
+  };
   syncInjector();
   const toolProbe = process.env.MEMSYS_TOOL_PROBE ?? null;
   const writeToolProbe = (deferred) => {
@@ -356,6 +393,15 @@ export async function apply(ctx, config = {}) {
             }),
           'memsys: ui config route',
         );
+        web.effect(
+          () =>
+            web.webServer.register({
+              kind: 'exact',
+              path: '/dsh-memsys/api/search',
+              handler: (req, res) => handlers.memsys_ui_search(req, res),
+            }),
+          'memsys: ui search route',
+        );
       });
     } catch {
       // profiles without webServer stay headless

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-memsys",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "A memory system plugin for DeepSeek Harness: append-only facts, candidates and adjudication, dreams, and budget-aware context injection.",
   "license": "MIT",
   "repository": {

package/src/runtime/inject-round.mjs

@@ -65,7 +65,7 @@ export function createRoundInjector({
     }
     const sessionId = sessionIdOf(turn) ?? state.sessionId;
     counter += 1;
-    const roundId = turn?.id ?? turn?.roundId ?? `turn-${counter}`;
+    const roundId = turn?.id ?? turn?.roundId ?? `turn-${Date.now()}-${counter}`;
     let result;
     try {
       result = compileRound({

package/src/runtime/service.mjs

@@ -0,0 +1,178 @@
+import { objectId, payloadHash } from '../identity.mjs';
+import { withImmediate } from '../storage/open.mjs';
+import {
+  insertCandidate,
+  insertEvidence,
+  insertObservation,
+  getObservation,
+} from '../storage/repositories.mjs';
+import { searchMemories } from '../read/search.mjs';
+import { compileRound } from '../context/compile.mjs';
+import { conservativeTokens } from '../context/budget.mjs';
+import { recordSelfNotes } from '../write/self-note.mjs';
+import { WriteError } from '../write/authority.mjs';
+
+const SERVICE_ROLE = 'model';
+
+function assertCaller(caller = {}) {
+  if (caller.role === 'owner' || caller.role === 'master' || caller.isOwner === true) {
+    throw new WriteError('validation_error', { field: 'role', reason: 'service_caller_not_owner' });
+  }
+}
+
+function candidateIdFor(source, externalId) {
+  return objectId('cand', `svc:${source}:${externalId}`);
+}
+
+export function createMemSysService({ main, control, clock }) {
+  const deps = { main, control, clock };
+  return {
+    version: 1,
+
+    ingest(input = {}, caller = {}) {
+      assertCaller(caller);
+      const source = String(input.source ?? '').trim();
+      const externalId = String(input.externalId ?? '').trim();
+      const text = String(input.text ?? '');
+      if (!source || !externalId || !text) {
+        throw new WriteError('validation_error', { field: 'source/externalId/text' });
+      }
+      const obsKey = `svc:${source}:${externalId}`;
+      const observationId = objectId('obs', obsKey);
+      const candidateId = candidateIdFor(source, externalId);
+      const existing = getObservation(main, observationId);
+      if (existing) {
+        const candidate = main.prepare('SELECT id FROM candidates WHERE observation_id = ?').get(observationId);
+        return { status: 'duplicate', candidateId: candidate?.id ?? null };
+      }
+      const at = input.at ?? clock.at().at;
+      const origin = `source:${source}:${externalId}`;
+      const sourceUnit = `bytes:0:${Buffer.byteLength(text, 'utf8')}`;
+      withImmediate(main, () => {
+        insertObservation(main, {
+          id: observationId,
+          idempotency_key: obsKey,
+          at,
+          payload_hash: payloadHash({ text, source, externalId }),
+          text,
+          source: 'file',
+          author_kind: 'file',
+          runtime_refs: JSON.stringify({ source, externalId, url: input.url ?? null, author: input.author ?? null }),
+          origin: JSON.stringify([origin]),
+          lossy: 0,
+          state_snapshot: '{}',
+          initial_strength: 0.5,
+          recorded_at: at,
+        });
+        insertCandidate(main, {
+          id: candidateId,
+          idempotency_key: obsKey,
+          at,
+          payload_hash: payloadHash({ text, why: 'service ingest', type: input.kind ?? 'fact', scene: input.scene ?? 'work', sourceUnit }),
+          observation_id: observationId,
+          source_unit: sourceUnit,
+          source_path: 'tool',
+          text,
+          detail: null,
+          why: 'service ingest',
+          type: input.kind ?? 'fact',
+          scene: input.scene ?? 'work',
+          scope: input.scope ?? 'work-only',
+          tags: JSON.stringify(input.tags ?? []),
+          topic_key: null,
+          topic_components: null,
+          registry_revision: null,
+          structured_value: null,
+          semantic_status: 'proposed',
+          record_kind: 'assertion',
+          origin: JSON.stringify([origin]),
+          confidence: 0.5,
+          lossy: 0,
+          start_at: input.at ?? null,
+          end_at: null,
+          prec_start: 'unknown',
+          prec_end: 'unknown',
+          time_state: 'point',
+          due_at: null,
+          weight: 5,
+          pointer_status: 'unknown',
+          pointer_location: input.url ?? null,
+          pointer_search_hint: null,
+          judgment_id: null,
+          key_status: 'unresolved',
+          binding_status: 'proposed',
+          binding_basis: JSON.stringify({ ruleRevision: 'topic-v1', source: 'service' }),
+          origin_mode: 'inherited',
+          creator_session_id: caller.sessionId ?? 'service',
+          owner_touched: 0,
+          reason: null,
+          resolved_from: null,
+          state_snapshot: '{}',
+          initial_strength: 0.5,
+          status: 'pending',
+          promoted_at: null,
+          rejected_reason: null,
+          review_policy: 'candidate-v1',
+          policy_revision: '1',
+          deadline_at: null,
+          created_input_seq: 1,
+          recorded_at: at,
+        });
+        insertEvidence(main, {
+          id: objectId('ev', `svc:${candidateId}`),
+          memory_id: null,
+          candidate_id: candidateId,
+          observation_id: observationId,
+          source_memory_id: null,
+          role: 'basis',
+          source_span: sourceUnit,
+          at,
+        });
+      });
+      return { status: 'accepted', candidateId, observationId };
+    },
+
+    search(query = {}) {
+      return searchMemories({
+        main, clock,
+        keywords: query.q ?? null,
+        scene: query.scene ?? null,
+        maxChars: query.limit ? Math.max(1000, Math.min(16000, Number(query.limit) * 200)) : 8000,
+      });
+    },
+
+    directory(query = {}) {
+      const budget = Number.isFinite(query.budget) ? query.budget : 4000;
+      const result = compileRound({
+        main, control, clock,
+        sessionId: 'service-directory',
+        roundId: 'service-directory',
+        mode: query.scene === 'life' ? 'life' : 'work',
+        tokenizer: conservativeTokens,
+        H: budget,
+      });
+      return result?.section?.text ?? '';
+    },
+
+    recordSelf(input = {}, caller = {}) {
+      assertCaller(caller);
+      const text = String(input.text ?? '');
+      if (!text) throw new WriteError('validation_error', { field: 'text' });
+      const runtime = {
+        role: SERVICE_ROLE,
+        identity: caller.agentId ?? caller.sessionId ?? 'service',
+        agentId: caller.agentId ?? null,
+        sessionId: caller.sessionId ?? 'service',
+        callId: caller.callId ?? 'service',
+      };
+      return recordSelfNotes(runtime, {
+        items: [{ text, tags: input.tags ?? [], kind: 'self_note' }],
+      }, deps);
+    },
+  };
+}
+
+export function provideMemSysService(ctx, service) {
+  if (typeof ctx?.provide !== 'function') throw new WriteError('service_unavailable', { reason: 'provide_missing' });
+  return ctx.provide('memsys', service, (value) => Boolean(value && value.version === 1));
+}

package/src/runtime/summary.mjs

@@ -12,17 +12,28 @@ import {
   resolveModulesDetail,
   writeUiConfig,
 } from './ui-config.mjs';
+import { searchMemories } from '../read/search.mjs';
 
 const RECENT_LIMIT = 5;
-const TEXT_LIMIT = 80;
+const SEARCH_LIMIT_DEFAULT = 20;
+const SEARCH_LIMIT_MAX = 50;
+const QUERY_MAX_CHARS = 200;
+// 主人要求：卡片展示 120 字（按码点截断，预算保护仍在 host 侧）
+const TEXT_LIMIT = 120;
 const BODY_LIMIT = 4096;
 
 const truncate = (text) => Array.from(String(text ?? '')).slice(0, TEXT_LIMIT).join('');
 
-/** Three counts, the five latest memories, and the effective module map. */
+/** Three counts, the five latest memories, the module map, and injector health. */
 export function buildSummary(
   main,
-  { dataDir = null, modules = DEFAULT_MODULES, modulesSource = 'default', autoInject = undefined } = {},
+  {
+    dataDir = null,
+    modules = DEFAULT_MODULES,
+    modulesSource = 'default',
+    autoInject = undefined,
+    inject = { level: 'unavailable', reason: 'not_started' },
+  } = {},
 ) {
   const db = typeof main === 'function' ? main() : main;
   const one = (sql, ...params) => Number(db.prepare(sql).get(...params)?.n ?? 0);
@@ -42,6 +53,98 @@ export function buildSummary(
     auto_inject_source: modulesSource,
     modules: effective,
     modules_source: modulesSource,
+    // Without this the "on" switch can be a lie: the injector may be running on
+    // tools-only text because no tokenizer/H reached it.
+    inject: { level: inject?.level ?? 'unavailable', reason: inject?.reason ?? null },
+  };
+}
+
+/**
+ * Search over the existing retrieval layer — no second query implementation.
+ * The search layer returns ids and text; kind/created_at come from one lookup by
+ * id, and per-item score is not exposed by it (null rather than invented).
+ */
+export function buildSearch(main, { q, limit = SEARCH_LIMIT_DEFAULT, clock } = {}) {
+  const db = typeof main === 'function' ? main() : main;
+  const result = searchMemories({ main: db, clock, keywords: q, maxChars: 16000 });
+  if (result?.status !== 'ok') return { status: 'error', code: result?.code ?? 'search_failed' };
+  const hits = result.hits ?? [];
+  const ids = hits.map((hit) => hit.id);
+  const meta = new Map();
+  if (ids.length > 0) {
+    const placeholders = ids.map(() => '?').join(',');
+    for (const row of db.prepare(`SELECT id, type, recorded_at FROM memories WHERE id IN (${placeholders})`).all(...ids)) {
+      meta.set(row.id, row);
+    }
+  }
+  const items = hits.slice(0, limit).map((hit) => ({
+    id: hit.id,
+    text: truncate(hit.text),
+    kind: meta.get(hit.id)?.type ?? null,
+    created_at: meta.get(hit.id)?.recorded_at ?? null,
+    score: null,
+  }));
+  return { status: 'ok', q, items, total: Number(result.direct_hit_count ?? items.length) };
+}
+
+function readQuery(url) {
+  const raw = String(url ?? '');
+  const index = raw.indexOf('?');
+  if (index < 0) return new URLSearchParams('');
+  try {
+    return new URLSearchParams(raw.slice(index + 1));
+  } catch {
+    return new URLSearchParams('');
+  }
+}
+
+/**
+ * GET /dsh-memsys/api/search?q=…&limit=…
+ * Same loopback + same-origin gate as the summary route; text is truncated to
+ * the same 120 codepoints the panel shows, and always keeps its id.
+ */
+export function createSearchHandler({ main, clock, logger = console } = {}) {
+  const send = (res, status, payload) => {
+    res.statusCode = status;
+    res.setHeader('content-type', 'application/json');
+    res.setHeader('cache-control', 'no-store');
+    res.end(JSON.stringify(payload));
+  };
+
+  return (req, res) => {
+    if (!isLoopback(req) || !sameOrigin(req)) {
+      send(res, 403, { error: 'forbidden' });
+      return;
+    }
+    if (req.method && req.method !== 'GET') {
+      send(res, 405, { error: 'method_not_allowed' });
+      return;
+    }
+    const params = readQuery(req.url);
+    const q = String(params.get('q') ?? '').trim();
+    if (!q) {
+      send(res, 400, { error: 'empty_query' });
+      return;
+    }
+    if (Array.from(q).length > QUERY_MAX_CHARS) {
+      send(res, 400, { error: 'query_too_long' });
+      return;
+    }
+    const rawLimit = Number(params.get('limit'));
+    const limit = Number.isFinite(rawLimit) && rawLimit > 0
+      ? Math.min(SEARCH_LIMIT_MAX, Math.floor(rawLimit))
+      : SEARCH_LIMIT_DEFAULT;
+    try {
+      const result = buildSearch(main, { q, limit, clock });
+      if (result.status !== 'ok') {
+        send(res, 503, { error: 'search_unavailable', message: String(result.code) });
+        return;
+      }
+      send(res, 200, { q: result.q, items: result.items, total: result.total });
+    } catch (err) {
+      logger?.warn?.(`[dsh-memsys] search failed: ${err?.message ?? err}`);
+      send(res, 503, { error: 'search_unavailable', message: String(err?.code ?? err?.message ?? err) });
+    }
   };
 }
 
@@ -87,6 +190,7 @@ export function createSummaryHandler({
       modules,
       source: current.source ?? 'default',
       auto_inject: modules?.context !== false,
+      inject: current.inject ?? { level: 'unavailable', reason: 'not_started' },
     };
   };
 
@@ -165,6 +269,7 @@ export function createSummaryHandler({
           modules: state.modules,
           modulesSource: state.source,
           autoInject: state.auto_inject,
+          inject: state.inject,
         }),
       );
     } catch (err) {

package/test/p6-service.test.mjs

@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { createMemSysService } from '../src/runtime/service.mjs';
+import { ingestInput } from '../src/write/observe.mjs';
+import { promoteCandidate, recordCandidates } from '../src/write/candidate.mjs';
+import { createTestContext, mutableClock } from './helpers/fixtures.mjs';
+import { fakeRuntime } from './helpers/runtime.mjs';
+
+let seq = 0;
+function seedMemory(ctx, text) {
+  seq += 1;
+  const runtime = fakeRuntime({ role: 'daily', identity: 'svc', callId: 'svc-' + seq, messageSeq: 32000 + seq });
+  const observation = ingestInput(runtime, { text: 'svc-' + seq, messageSeq: 32000 + seq }, { main: ctx.main, control: ctx.control, clock: ctx.clock });
+  const created = recordCandidates(runtime, {
+    items: [{ observationId: observation.observation.id, text, why: 'w', type: 'fact', scene: 'work', scope: 'work-only', evidenceRefs: [{ observationId: observation.observation.id, sourceSpan: 'bytes:0:3' }] }],
+  }, { main: ctx.main, control: ctx.control, clock: ctx.clock });
+  promoteCandidate(runtime, created.items[0].id, null, { main: ctx.main, control: ctx.control, clock: ctx.clock });
+}
+
+test('P6/service: same externalId does not add rows; product is a candidate', (t) => {
+  const ctx = createTestContext({ clock: mutableClock().clock });
+  t.after(() => ctx.cleanup());
+  const service = createMemSysService({ main: ctx.main, control: ctx.control, clock: ctx.clock });
+  const first = service.ingest({ source: 'rss', externalId: 'a-1', kind: 'fact', text: '外部文章正文' }, { sessionId: 's-svc', callId: 'c-svc' });
+  const second = service.ingest({ source: 'rss', externalId: 'a-1', kind: 'fact', text: '外部文章正文' }, { sessionId: 's-svc', callId: 'c-svc' });
+  assert.equal(first.status, 'accepted');
+  assert.equal(second.status, 'duplicate');
+  assert.equal(ctx.main.prepare('SELECT COUNT(*) AS n FROM candidates').get().n, 1);
+  assert.equal(ctx.main.prepare('SELECT COUNT(*) AS n FROM memories').get().n, 0);
+});
+
+test('P6/service: owner identity is rejected', (t) => {
+  const ctx = createTestContext({ clock: mutableClock().clock });
+  t.after(() => ctx.cleanup());
+  const service = createMemSysService({ main: ctx.main, control: ctx.control, clock: ctx.clock });
+  assert.throws(
+    () => service.ingest({ source: 'rss', externalId: 'a-2', text: 'x' }, { role: 'owner' }),
+    (err) => err.code === 'validation_error',
+  );
+});
+
+test('P6/service: directory returns a string containing a real memory id', (t) => {
+  const ctx = createTestContext({ clock: mutableClock().clock });
+  t.after(() => ctx.cleanup());
+  seedMemory(ctx, '服务目录记忆');
+  const memory = ctx.main.prepare('SELECT id FROM memories LIMIT 1').get();
+  const service = createMemSysService({ main: ctx.main, control: ctx.control, clock: ctx.clock });
+  const text = service.directory({ scene: 'work', budget: 2000 });
+  assert.equal(typeof text, 'string');
+  assert.ok(text.includes(memory.id), text.slice(0, 200));
+});

package/test/p6-ui-summary.test.mjs

@@ -12,7 +12,7 @@ import {
   resolveModulesDetail,
   writeUiConfig,
 } from '../src/runtime/ui-config.mjs';
-import { buildSummary, createSummaryHandler } from '../src/runtime/summary.mjs';
+import { buildSummary, createSearchHandler, createSummaryHandler } from '../src/runtime/summary.mjs';
 import { registerHostTools } from '../src/runtime/tools.mjs';
 import { conservativeTokens } from '../src/context/budget.mjs';
 import { insertRow } from '../src/storage/repositories.mjs';
@@ -44,12 +44,12 @@ function fakeRes() {
   };
 }
 
-function fakeReq({ method = 'GET', headers = {}, body = null, remoteAddress = '127.0.0.1' } = {}) {
+function fakeReq({ method = 'GET', headers = {}, body = null, remoteAddress = '127.0.0.1', url = '/dsh-memsys/api/summary' } = {}) {
   const listeners = new Map();
   const req = {
     method,
     headers,
-    url: '/dsh-memsys/api/summary',
+    url,
     socket: { remoteAddress },
     on(event, handler) {
       listeners.set(event, handler);
@@ -103,6 +103,7 @@ test('P6/UI: modules default to all true and the summary exposes seven keys', (t
     'auto_inject_source',
     'candidates',
     'data_dir',
+    'inject',
     'memories',
     'modules',
     'modules_source',
@@ -283,7 +284,8 @@ test('P6/UI: counts only open candidates, pending-due memories, and truncates re
   assert.equal(summary.candidates, 2, 'promoted candidates are history, not "候选"');
   assert.equal(summary.pending_due, 1);
   assert.equal(summary.recent.length, 2);
-  assert.equal(Array.from(summary.recent.find((row) => row.id === dueMemory.id).text).length, 80);
+  // 主人要求 120 码点（原来是 80）；这里改的是需求，不是放宽判据。
+  assert.equal(Array.from(summary.recent.find((row) => row.id === dueMemory.id).text).length, 120);
 });
 
 test('P6/UI: routes reject off-loopback and cross-origin callers', () => {
@@ -399,6 +401,7 @@ test('P6/UI: with webServer the two exact routes serve loopback and reject cross
       [
         ['exact', '/dsh-memsys/api/summary'],
         ['exact', '/dsh-memsys/api/config'],
+        ['exact', '/dsh-memsys/api/search'],
       ],
     );
 
@@ -539,12 +542,9 @@ test('P6/UI: the registered section text carries a real memory id, and nothing m
   };
 
   const on = capture();
-  const disposeOn = await apply(on.host, {
-    data_dir: ctx.dir,
-    tokenizer: conservativeTokens,
-    H: 20000,
-    mode: 'work',
-  });
+  // No explicit tokenizer/H: the plugin must default them, otherwise the
+  // injector only ever emits tools-only text and `context:true` is a dead shell.
+  const disposeOn = await apply(on.host, { data_dir: ctx.dir, mode: 'work' });
   try {
     assert.equal(on.sections.length, 1, 'context:true mounts exactly one section');
     const registered = on.sections[0];
@@ -552,6 +552,12 @@ test('P6/UI: the registered section text carries a real memory id, and nothing m
     const text = registered.text();
     assert.ok(text.includes(memory.id), 'the injected text carries the real memory id');
     assert.ok(text.length > 40, 'and it is not the empty/tools-only placeholder');
+
+    const summaryRes = fakeRes();
+    on.routes[0].handler(fakeReq({ headers: { host: '127.0.0.1:50478' } }), summaryRes);
+    const injectState = summaryRes.json().inject;
+    assert.notEqual(injectState.level, 'unavailable', 'the default tokenizer/H keep the injector alive');
+    assert.equal(injectState.reason, null);
   } finally {
     disposeOn();
   }
@@ -564,3 +570,54 @@ test('P6/UI: the registered section text carries a real memory id, and nothing m
     disposeOff();
   }
 });
+
+test('P6/UI: search route returns id-bearing items from the existing retrieval layer', (t) => {
+  const ctx = createTestContext({ clock: mutableClock().clock });
+  t.after(() => ctx.cleanup());
+
+  const observation = makeObservation(ctx, { text: '香菜不要放，闻到就想吐。' });
+  insertRow(ctx.main, 'observations', observation);
+  const candidate = makeCandidate(ctx, observation, { businessKey: 'ui-search-1', text: '不吃香菜' });
+  insertRow(ctx.main, 'candidates', candidate);
+  const memory = makeMemory(ctx, candidate, { businessKey: 'ui-search-mem' });
+  insertRow(ctx.main, 'memories', memory);
+
+  const handler = createSearchHandler({ main: ctx.main, clock: ctx.clock });
+  const res = fakeRes();
+  handler(fakeReq({ headers: { host: '127.0.0.1:50478' }, url: '/dsh-memsys/api/search?q=%E9%A6%99%E8%8F%9C&limit=5' }), res);
+  assert.equal(res.statusCode, 200);
+  const body = res.json();
+  assert.equal(body.q, '香菜');
+  assert.ok(Array.isArray(body.items) && body.items.length >= 1);
+  const first = body.items[0];
+  assert.equal(first.id, memory.id);
+  assert.equal(typeof first.text, 'string');
+  assert.equal(first.kind, 'episode');
+  assert.ok(Array.from(first.text).length <= 120);
+  assert.equal(typeof body.total, 'number');
+
+  const empty = fakeRes();
+  handler(fakeReq({ url: '/dsh-memsys/api/search?q=' }), empty);
+  assert.equal(empty.statusCode, 400);
+  assert.equal(empty.json().error, 'empty_query');
+
+  const cross = fakeRes();
+  handler(
+    fakeReq({ headers: { origin: 'https://evil.example', host: '127.0.0.1:50478' }, url: '/dsh-memsys/api/search?q=x' }),
+    cross,
+  );
+  assert.equal(cross.statusCode, 403);
+});
+
+test('P6/UI: the browser half renders a debounced search box and never builds HTML', () => {
+  const code = fs.readFileSync(path.join(ROOT, 'client.js'), 'utf8');
+  assert.ok(code.includes("placeholder: '搜记忆…'"), 'search box with the agreed placeholder');
+  assert.ok(code.includes("const SEARCH = '/dsh-memsys/api/search'"));
+  assert.ok(code.includes('encodeURIComponent(query)'));
+  assert.ok(/setTimeout\(run, 250\)/.test(code), 'input is debounced by 250ms');
+  assert.ok(code.includes("'没找到匹配的记忆'"));
+  assert.ok(code.includes("'搜索不可用'"));
+  // The only innerHTML-ish call is the <style> block; result rows are React text nodes.
+  assert.equal((code.match(/dangerouslySetInnerHTML/g) ?? []).length, 1);
+  assert.equal((code.match(/innerHTML/g) ?? []).length, 0, 'no raw innerHTML: rows are text nodes');
+});