sage-mem 0.1.2 → 0.4.0

package/LICENSE

@@ -1,21 +1,202 @@
-MIT License
-
-Copyright (c) 2026 Bowen Zheng
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,5 @@
+Sage Plugins
+Copyright 2026 gezi-wen
+
+This product includes software developed by the Sage project
+(https://github.com/gezi-wen/sage-mem).

package/README.md

@@ -1,74 +1,46 @@
-# sage-mem · DSH 的记忆系统插件
+# sage-mem · DSH 的文件式记忆插件
 
 给 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)（DSH）装上**跨会话记忆**——agent 今天记住的事，明天的新会话自动想起来。
 
-## 为什么需要它
+记忆存在**本地 markdown 文件**里（frontmatter + 正文），不是数据库。透明、可检查、防膨胀。
 
-DSH 原生没有记忆系统。每个会话都是白纸：用户说过「我喜欢在深夜写代码」，下个会话再问「我喜欢什么」，agent 只能答不知道。
+## 为什么用文件
 
-sage-mem 补上这一块。它监听 DSH 的事件流，把会话内容沉淀到 SQLite，新会话启动时自动检索注入历史记忆。
+DSH 原生没有记忆系统，每个会话都是白纸。市面上的记忆方案大多走 SQLite + 常驻 worker：
 
-**中文优先**。市面上的记忆方案在中文检索上普遍失效（SQLite FTS5 默认分词器对中文全部 0 命中）。sage-mem 的 worker 用 trigram 分词 + 短词兜底，中文实测全命中。
+- 记忆写进数据库，**不透明**——想检查存了什么得查表，想清理要连数据库
+- 事件自动捕获会**膨胀**——"用户打了个招呼"这种无实质内容也被存进去
+- 需要一个**常驻 worker 进程** + 端口，多一份运维负担
+
+sage-mem 换成文件式：每条记忆一个 markdown 文件，直接用编辑器打开就能看、能改、能删。存不存由 agent 按规则判断，不是事件全捕获。没有 worker、没有 SQLite、没有端口。
 
 ## 功能
 
-- **自动捕获**：工具调用（读写文件、执行命令）自动记录，无需手动整理
-- **AI 压缩**：会话内容由 LLM 压缩成结构化记忆（事实、摘要），中文输出
-- **跨会话注入**：新会话启动时自动检索并注入历史记忆，agent 不用自己翻
-- **中文检索**：trigram 分词（≥3 字查询）+ LIKE 兜底（<3 字短词如「猫」「芝麻」）
+- **按问题检索注入**：每次提问，插件扫记忆目录，按相关性把记忆注入 system prompt，agent 第一轮就「想起来」
+- **四类记忆**：`user`（用户是谁）/ `feedback`（工作方式指导）/ `project`（项目状态）/ `reference`（外部信息指针）
+- **文件透明**：记忆就是 `*.md` 文件，frontmatter 存元数据，正文存内容
+- **防膨胀**：写入靠规则引导 agent 判断「存不存」，无实质内容、能靠代码/git 推导的不存
+- **Web 文件管理器**（v0.4）：DSH 设置页「记忆管理」，浏览/查看/编辑/删除记忆文件，添加新记忆
 
 ## 架构
 
 ```
 DSH（Cordis 插件）
-  └─ sage-mem 插件（事件监听 → HTTP 转发）← 本仓库
-       │  HTTP 127.0.0.1
-       ▼
-sage-mem worker（Bun 常驻，fork 自 claude-mem）← gezi-wen/claude-mem
-       │
+  └─ sage-mem 插件（按问题检索 + 注入）← 本仓库
+       │  Node fs 直读
        ▼
-SQLite（FTS5 trigram 中文分词 + LLM 压缩）
+memory/ 目录（markdown 文件，4 类）
+  ├── user_*.md
+  ├── feedback_*.md
+  ├── project_*.md
+  ├── reference_*.md
+  └── MEMORY.md          ← 索引
 ```
 
-设计选择：记忆逻辑复用 [claude-mem](https://github.com/thedotmack/claude-mem)（Apache-2.0，9 万星），fork 后加中文修复，DSH 侧只写一个轻量桥接插件。改动最小，能追上游更新。
+没有 worker、没有 SQLite、没有 HTTP 端口、没有常驻进程。
 
 ## 安装
 
-### 1. 部署 worker
-
-```bash
-git clone https://github.com/gezi-wen/claude-mem.git
-cd claude-mem
-git checkout sage-mem-worker   # 含中文 trigram 修复
-bun install
-```
-
-配置 `~/.claude-mem/settings.json`（worker 数据目录）：
-
-```json
-{
-  "CLAUDE_MEM_PROVIDER": "openrouter",
-  "CLAUDE_MEM_OPENROUTER_BASE_URL": "https://api.deepseek.com",
-  "CLAUDE_MEM_OPENROUTER_MODEL": "deepseek-chat",
-  "CLAUDE_MEM_CHROMA_ENABLED": "false",
-  "CLAUDE_MEM_MODE": "code--zh"
-}
-```
-
-`~/.claude-mem/.env` 放 API key（任意 OpenAI 兼容服务均可，不限于 DeepSeek）：
-
-```
-OPENROUTER_API_KEY=<你的 API key>
-```
-
-启动：
-
-```bash
-bun src/services/worker-service.ts --daemon
-```
-
-### 2. 安装插件
-
 在你的 DSH profile 的 `package.json` 里加：
 
 ```json
@@ -96,22 +68,48 @@ bun src/services/worker-service.ts --daemon
 
 然后 `pnpm install` 重启 DSH。
 
+## 配置
+
+用环境变量 `SAGE_MEM_DIR` 指定记忆目录，默认 `~/.sage-mem/memory`：
+
+```
+SAGE_MEM_DIR=/path/to/your/memory
+```
+
+记忆文件格式：
+
+```markdown
+---
+name: 可选的短名
+description: 一句话说清这条记忆是什么（检索与列表都靠它）
+metadata:
+  type: user        # user / feedback / project / reference
+---
+
+记忆正文。
+```
+
+`feedback` 类建议带 `**Why:**`（原因）和 `**How to apply:**`（何时生效）两行，方便判断边界。
+
 ## 验证
 
-跨会话中文记忆链路（实测）：
+跨会话记忆链路（实测）：
 
-1. 会话 A 说「记住：我的猫叫芝麻，它喜欢晒太阳」
+1. 会话 A 说「记住：我的猫叫芝麻，它喜欢晒太阳」——agent 按规则写进 `memory/`
 2. 开新会话 B 问「我的猫叫什么」
-3. agent 直接答出「芝麻」——记忆自动注入，无需 agent 自己找
+3. agent 第一轮直接答出「芝麻」——记忆自动注入，无需 agent 自己找
+
+## 相关项目
+
+- [sage-persona](https://github.com/gezi-wen/sage-persona) — 人格（我是谁）
+- [sage-meta](https://github.com/gezi-wen/sage-meta) — 自检（我做得对吗）
 
-搭配 [sage-persona](https://github.com/gezi-wen/sage-persona)（我是谁）和 [sage-meta](https://github.com/gezi-wen/sage-meta)（我做得对吗）组成 Sage 三件套——这是三道题的第三道：**我下次应该怎么想**。
+sage-mem 是第三道：**我下次应该怎么想**——跨会话沉淀事实与教训。
 
-## 已知边界
+## 旧版
 
-- trigram 分词对 `<3` 字符查询无效，worker 已加 LIKE 兜底
-- worker 不可用时插件静默跳过（不阻塞 DSH），记忆功能暂缺
-- MVP 存储统一在 `project=sage` 空间，按工作区分项目是后续计划
+本仓库早期是 SQLite + worker 架构，已归档到 [`sqlite-worker`](../../tree/sqlite-worker) 分支。文件式是继任实现。
 
 ## License
 
-MIT（worker fork 为 Apache-2.0，见 [gezi-wen/claude-mem](https://github.com/gezi-wen/claude-mem)）
+Apache-2.0

package/lib/client.js

@@ -0,0 +1,432 @@
+/**
+ * sage-mem — 客户端半：DSH 设置页「记忆管理」界面（文件管理器）。
+ *
+ * 手写 ModuleLoader bundle（与官方 dsh-client-* 包的构建产物同格式）：
+ * window.__ModuleLoader__.load({ id, factory })，factory 内 require('react')
+ * 可用，module.exports 导出标准 Cordis 插件（apply/inject）。
+ *
+ * 数据通道：TypertRemoteService（host 半 MemoryGateway），通过
+ * ctx.get("remote.memory") 调用文件列表/读/写/删。remote 返回 {ok, value}
+ * 信封。浏览器侧无 zod，schema 手写（codec 只要求 mode==="strict" + parse）。
+ *
+ * 功能：浏览 memory 目录的 markdown 记忆文件（类型徽章 + 描述预览）、
+ * 查看/编辑全文、两步确认删除、添加新记忆（选类型 + 描述 + 正文）。
+ */
+
+window.__ModuleLoader__.load({
+	id: "sage-mem",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let react = require("react");
+		const h = react.createElement;
+
+		// ── 手写 strict codec（浏览器无 zod，typert 只要求 parse 方法）──
+		function parseSchema(shape) {
+			return {
+				parse(value) {
+					if (value === null || typeof value !== "object") throw new Error("sage-mem: invalid payload");
+					for (const [key, check] of Object.entries(shape)) {
+						if (!(key in value)) throw new Error("sage-mem: missing field " + key);
+						check(value[key]);
+					}
+					return value;
+				},
+			};
+		}
+		const isStr = (v) => { if (typeof v !== "string") throw new Error("expected string"); };
+		const isBool = (v) => { if (typeof v !== "boolean") throw new Error("expected boolean"); };
+		const isNum = (v) => { if (typeof v !== "number") throw new Error("expected number"); };
+		const strSchema = { parse(v) { isStr(v); return v; } };
+		const fileSchema = parseSchema({ "file": isStr, "type": isStr, "description": isStr, "size": isNum });
+		const listSchema = { parse(v) { if (!Array.isArray(v)) throw new Error("expected array"); v.forEach((f) => fileSchema.parse(f)); return v; } };
+		const readSchema = parseSchema({ "name": isStr, "content": isStr });
+		const writeSchema = parseSchema({ "ok": isBool, "file": isStr });
+		const deleteSchema = parseSchema({ "ok": isBool });
+
+		const TYPERT_REMOTE = {
+			package: "sage-mem",
+			descriptors: [
+				{
+					id: "sage-mem#memory/listFiles",
+					service: "memory",
+					namespace: "memory",
+					method: "listFiles",
+					invocation: { kind: "direct" },
+					parameters: [],
+					result: { mode: "strict", typeSymbol: "sage-mem/types#FileList", schema: listSchema },
+					sourceLocation: { "file": "workspace/sage-mem/lib/index.js", "line": 1, "column": 1 },
+				},
+				{
+					id: "sage-mem#memory/readFile",
+					service: "memory",
+					namespace: "memory",
+					method: "readFile",
+					invocation: { kind: "direct" },
+					parameters: [
+						{ name: "name", wire: "name", source: "json", codec: { mode: "strict", typeSymbol: "sage-mem/types#FileName", schema: strSchema } },
+					],
+					result: { mode: "strict", typeSymbol: "sage-mem/types#FileContent", schema: readSchema },
+					sourceLocation: { "file": "workspace/sage-mem/lib/index.js", "line": 1, "column": 1 },
+				},
+				{
+					id: "sage-mem#memory/writeFile",
+					service: "memory",
+					namespace: "memory",
+					method: "writeFile",
+					invocation: { kind: "direct" },
+					parameters: [
+						{ name: "name", wire: "name", source: "json", codec: { mode: "strict", typeSymbol: "sage-mem/types#FileName", schema: strSchema } },
+						{ name: "content", wire: "content", source: "json", codec: { mode: "strict", typeSymbol: "sage-mem/types#FileContent", schema: strSchema } },
+					],
+					result: { mode: "strict", typeSymbol: "sage-mem/types#WriteResult", schema: writeSchema },
+					sourceLocation: { "file": "workspace/sage-mem/lib/index.js", "line": 1, "column": 1 },
+				},
+				{
+					id: "sage-mem#memory/deleteFile",
+					service: "memory",
+					namespace: "memory",
+					method: "deleteFile",
+					invocation: { kind: "direct" },
+					parameters: [
+						{ name: "name", wire: "name", source: "json", codec: { mode: "strict", typeSymbol: "sage-mem/types#FileName", schema: strSchema } },
+					],
+					result: { mode: "strict", typeSymbol: "sage-mem/types#DeleteResult", schema: deleteSchema },
+					sourceLocation: { "file": "workspace/sage-mem/lib/index.js", "line": 1, "column": 1 },
+				},
+			],
+		};
+
+		const CSS = [
+			".smem-root{display:flex;flex-direction:column;gap:12px;font-size:13px;line-height:1.55;color:var(--dsw-alias-label-primary);max-width:760px;}",
+			".smem-head{display:flex;align-items:center;gap:8px;flex-wrap:wrap;}",
+			".smem-title{font-size:15px;font-weight:600;}",
+			".smem-dot{width:8px;height:8px;border-radius:50%;background:var(--dsw-alias-state-success-primary,#22c55e);flex:none;}",
+			".smem-dot--bad{background:var(--dsw-alias-state-error-primary,#ef4444);}",
+			".smem-muted{color:var(--dsw-alias-label-secondary);font-size:12px;}",
+			".smem-toolbar{display:flex;align-items:center;gap:8px;flex-wrap:wrap;}",
+			".smem-search{flex:1;min-width:160px;border:1px solid var(--dsw-alias-border-l1);border-radius:8px;background:var(--dsw-alias-bg-layer-2);color:inherit;padding:5px 10px;font-size:12px;outline:none;font-family:inherit;}",
+			".smem-search:focus{border-color:var(--dsw-alias-brand-primary,#4d76e6);}",
+			".smem-btn{border:1px solid var(--dsw-alias-border-l2);background:transparent;color:var(--dsw-alias-label-primary);border-radius:8px;padding:4px 12px;font-size:12px;cursor:pointer;font-family:inherit;white-space:nowrap;}",
+			".smem-btn:hover{border-color:var(--dsw-alias-brand-primary,#4d76e6);color:var(--dsw-alias-brand-primary,#4d76e6);}",
+			".smem-btn:disabled{opacity:.5;cursor:default;}",
+			".smem-btn-primary{background:var(--dsw-alias-brand-primary,#4d76e6);border-color:var(--dsw-alias-brand-primary,#4d76e6);color:var(--dsw-alias-bg-base,#fff);}",
+			".smem-btn-primary:hover{color:var(--dsw-alias-bg-base,#fff);opacity:.88;}",
+			".smem-btn-danger-ghost{color:var(--dsw-alias-state-error-primary,#ef4444);border-color:var(--dsw-alias-border-l2);}",
+			".smem-btn-danger{background:var(--dsw-alias-state-error-primary,#dc2626);border-color:var(--dsw-alias-state-error-primary,#dc2626);color:#fff;}",
+			".smem-btn-danger:hover{color:#fff;opacity:.9;}",
+			".smem-list{display:flex;flex-direction:column;gap:10px;}",
+			".smem-card{border:1px solid var(--dsw-alias-border-l1);border-radius:10px;background:var(--dsw-alias-bg-layer-1);padding:10px 12px;display:flex;flex-direction:column;gap:6px;}",
+			".smem-card-head{display:flex;align-items:center;gap:8px;flex-wrap:wrap;}",
+			".smem-card-title{font-weight:600;flex:1;min-width:120px;overflow-wrap:anywhere;text-align:left;font-family:ui-monospace,SFMono-Regular,Menlo,monospace;}",
+			".smem-badge{display:inline-flex;align-items:center;gap:4px;font-size:11px;color:var(--dsw-alias-label-secondary);border:1px solid var(--dsw-alias-border-l1);border-radius:6px;padding:1px 6px;white-space:nowrap;}",
+			".smem-narrative{color:var(--dsw-alias-label-secondary);font-size:12.5px;white-space:pre-wrap;overflow-wrap:anywhere;}",
+			'.smem-narrative[data-clamp="1"]{display:-webkit-box;-webkit-line-clamp:3;-webkit-box-orient:vertical;overflow:hidden;cursor:pointer;}',
+			".smem-card-foot{display:flex;justify-content:flex-end;}",
+			".smem-actions{display:flex;gap:6px;}",
+			".smem-form{border:1px solid var(--dsw-alias-border-l2);border-radius:10px;padding:12px;background:var(--dsw-alias-bg-layer-2);display:flex;flex-direction:column;gap:8px;}",
+			".smem-form-title{font-weight:600;font-size:13px;}",
+			".smem-label{font-size:12px;color:var(--dsw-alias-label-secondary);}",
+			".smem-input,.smem-textarea{width:100%;box-sizing:border-box;border:1px solid var(--dsw-alias-border-l1);border-radius:8px;background:var(--dsw-alias-bg-base);color:inherit;padding:6px 10px;font-size:13px;outline:none;font-family:inherit;}",
+			".smem-input:focus,.smem-textarea:focus{border-color:var(--dsw-alias-brand-primary,#4d76e6);}",
+			".smem-textarea{resize:vertical;min-height:72px;}",
+			".smem-row{display:flex;gap:8px;align-items:center;flex-wrap:wrap;}",
+			".smem-chip{border:1px solid var(--dsw-alias-border-l1);background:transparent;color:var(--dsw-alias-label-secondary);border-radius:999px;padding:3px 12px;font-size:12px;cursor:pointer;font-family:inherit;}",
+			".smem-chip:hover{border-color:var(--dsw-alias-border-l2);}",
+			'.smem-chip[data-on="1"]{border-color:var(--dsw-alias-brand-primary,#4d76e6);color:var(--dsw-alias-brand-primary,#4d76e6);}',
+			".smem-chips{display:flex;gap:6px;flex-wrap:wrap;}",
+			".smem-err{border:1px solid var(--dsw-alias-state-error-primary,#ef4444);color:var(--dsw-alias-state-error-primary,#ef4444);border-radius:8px;padding:6px 10px;font-size:12px;white-space:pre-wrap;overflow-wrap:anywhere;}",
+			".smem-ok{color:var(--dsw-alias-state-success-primary,#16a34a);font-size:12px;}",
+			".smem-empty{border:1px dashed var(--dsw-alias-border-l2);border-radius:10px;padding:22px 14px;text-align:center;color:var(--dsw-alias-label-secondary);font-size:12.5px;}",
+		].join("\n");
+
+		const TYPE_META = {
+			user: ["👤", "用户"],
+			feedback: ["📌", "反馈"],
+			project: ["📁", "项目"],
+			reference: ["🔗", "参考"],
+		};
+		const TYPE_ORDER = ["user", "feedback", "project", "reference"];
+
+		function fmtSize(n) {
+			if (n < 1024) return n + " B";
+			if (n < 1024 * 1024) return (n / 1024).toFixed(1) + " KB";
+			return (n / 1024 / 1024).toFixed(1) + " MB";
+		}
+
+		/** 拆 typert remote 的 {ok, value} 信封。 */
+		function unwrap(result) {
+			return result && result.ok ? result.value : result;
+		}
+
+		function Chip(props) {
+			return h("button", {
+				type: "button",
+				className: "smem-chip",
+				"data-on": props.on ? "1" : "0",
+				onClick: props.onClick,
+			}, props.label);
+		}
+
+		function Card(props) {
+			const item = props.item;
+			const meta = TYPE_META[item.type] || TYPE_META.reference;
+			const isOpen = !!props.expanded;
+			return h("div", { className: "smem-card", key: item.file }, [
+				h("div", { className: "smem-card-head", key: "head" }, [
+					h("span", { className: "smem-badge", key: "badge", title: "类型 " + String(item.type) }, meta[0] + " " + meta[1]),
+					h("span", { className: "smem-card-title", key: "title" }, item.file),
+					h("span", { className: "smem-muted", key: "size" }, fmtSize(item.size)),
+				]),
+				item.description
+					? h("div", {
+							className: "smem-narrative",
+							"data-clamp": isOpen ? "0" : "1",
+							key: "body",
+							onClick: function () { props.onToggle(item.file); },
+							title: isOpen ? "点击收起" : "点击展开全文",
+						}, String(item.description))
+					: null,
+				h("div", { className: "smem-card-foot", key: "foot" },
+					h("div", { className: "smem-actions", key: "acts" },
+						props.deleting
+							? [
+									h("button", { type: "button", className: "smem-btn smem-btn-danger", key: "yes", onClick: function () { props.onConfirmDelete(item.file); } }, "确认删除"),
+									h("button", { type: "button", className: "smem-btn", key: "no", onClick: function () { props.onCancelDelete(); } }, "取消"),
+								]
+							: [
+									h("button", { type: "button", className: "smem-btn", key: "edit", onClick: function () { props.onEdit(item.file); } }, "编辑"),
+									h("button", { type: "button", className: "smem-btn smem-btn-danger-ghost", key: "del", onClick: function () { props.onAskDelete(item.file); } }, "删除"),
+								])),
+			]);
+		}
+
+		function Section(props) {
+			const remote = props.ctx.get("remote.memory");
+			const sItems = react.useState([]);
+			const items = sItems[0], setItems = sItems[1];
+			const sLoading = react.useState(false);
+			const loading = sLoading[0], setLoading = sLoading[1];
+			const sError = react.useState(null);
+			const error = sError[0], setError = sError[1];
+			const sNotice = react.useState("");
+			const notice = sNotice[0], setNotice = sNotice[1];
+			const sQuery = react.useState("");
+			const query = sQuery[0], setQuery = sQuery[1];
+			const sExpanded = react.useState({});
+			const expanded = sExpanded[0], setExpanded = sExpanded[1];
+			const sDeleting = react.useState(null);
+			const deleting = sDeleting[0], setDeleting = sDeleting[1];
+			const sFormOpen = react.useState(false);
+			const formOpen = sFormOpen[0], setFormOpen = sFormOpen[1];
+			const sEditingFile = react.useState(null);
+			const editingFile = sEditingFile[0], setEditingFile = sEditingFile[1];
+			const sFormType = react.useState("feedback");
+			const formType = sFormType[0], setFormType = sFormType[1];
+			const sFormName = react.useState("");
+			const formName = sFormName[0], setFormName = sFormName[1];
+			const sFormDesc = react.useState("");
+			const formDesc = sFormDesc[0], setFormDesc = sFormDesc[1];
+			const sFormBody = react.useState("");
+			const formBody = sFormBody[0], setFormBody = sFormBody[1];
+			const sBusy = react.useState(false);
+			const busy = sBusy[0], setBusy = sBusy[1];
+			const sOk = react.useState(false);
+			const dirOk = sOk[0], setDirOk = sOk[1];
+
+			function load() {
+				setLoading(true);
+				setError(null);
+				remote.listFiles()
+					.then(function (res) {
+						if (res && typeof res === "object" && res.ok === false) {
+							const msg = res.error && res.error.message ? res.error.message : "remote 调用失败";
+							throw new Error("listFiles RPC 失败: " + msg);
+						}
+						const list = unwrap(res);
+						setItems(Array.isArray(list) ? list : []);
+						setDirOk(true);
+					})
+					.catch(function (e) { setError(String((e && e.message) || e)); setDirOk(false); })
+					.then(function () { setLoading(false); });
+			}
+
+			react.useEffect(function () { load(); }, []);
+
+			function closeForm() {
+				setFormOpen(false); setEditingFile(null); setFormName(""); setFormDesc(""); setFormBody(""); setFormType("feedback");
+			}
+
+			function openEdit(file) {
+				setError(null);
+				setBusy(true);
+				remote.readFile(file)
+					.then(function (res) {
+						const data = unwrap(res);
+						const content = (data && data.content) || "";
+						const fm = content.match(/^---\n([\s\S]*?)\n---\n?/);
+						let type = "reference";
+						let desc = "";
+						let body = content;
+						if (fm) {
+							body = content.slice(fm[0].length);
+							const t = fm[1].match(/type:\s*(\S+)/);
+							if (t) type = t[1];
+							const d = fm[1].match(/description:\s*"?(.+?)"?\n/);
+							if (d) desc = d[1].replace(/["']/g, "");
+						}
+						setEditingFile(file);
+						setFormName(file);
+						setFormType(TYPE_ORDER.indexOf(type) >= 0 ? type : "reference");
+						setFormDesc(desc);
+						setFormBody(body);
+						setFormOpen(true);
+					})
+					.catch(function (e) { setError(String((e && e.message) || e)); })
+					.then(function () { setBusy(false); });
+			}
+
+			function openAdd() {
+				setError(null);
+				setEditingFile(null);
+				setFormName("");
+				setFormType("feedback");
+				setFormDesc("");
+				setFormBody("");
+				setFormOpen(true);
+			}
+
+			function buildFrontmatter(type, desc) {
+				return "---\nname: \"\"\ndescription: \"" + desc.replace(/"/g, "'") + "\"\nmetadata:\n  type: " + type + "\n---\n\n";
+			}
+
+			function submit() {
+				if (!formDesc.trim()) { setError("描述不能为空"); return; }
+				setBusy(true); setError(null); setNotice("");
+				const type = formType;
+				const name = (formName.trim() || (type + "_note.md"));
+				const safeName = name.endsWith(".md") ? name : name + ".md";
+				const content = buildFrontmatter(type, formDesc.trim()) + formBody;
+				remote.writeFile(safeName, content)
+					.then(function () {
+						closeForm();
+						setNotice(editingFile ? "已更新 " + safeName : "已保存 " + safeName);
+						load();
+					})
+					.catch(function (e) { setError(String((e && e.message) || e)); })
+					.then(function () { setBusy(false); });
+			}
+
+			function confirmDelete(file) {
+				setBusy(true); setError(null); setNotice("");
+				remote.deleteFile(file)
+					.then(function () {
+						setDeleting(null);
+						setNotice("已删除 " + file);
+						load();
+					})
+					.catch(function (e) { setError(String((e && e.message) || e)); })
+					.then(function () { setBusy(false); });
+			}
+
+			const q = query.trim().toLowerCase();
+			const filtered = items.filter(function (it) {
+				if (!q) return true;
+				const hay = ((it.file || "") + "\n" + (it.description || "") + "\n" + (it.type || "")).toLowerCase();
+				return hay.indexOf(q) >= 0;
+			});
+
+			return h("div", { className: "smem-root" }, [
+				h("div", { className: "smem-head", key: "head" }, [
+					h("span", { className: "smem-title", key: "t" }, "记忆文件（sage-mem）"),
+					h("span", { className: "smem-dot" + (dirOk ? "" : " smem-dot--bad"), key: "dot", title: dirOk ? "memory 目录可读" : "memory 目录不可读" }),
+					h("span", { className: "smem-muted", key: "st" }, dirOk ? "目录可读" : "目录不可读"),
+					h("span", { className: "smem-badge", key: "cnt" }, "共 " + String(items.length) + " 个文件"),
+				]),
+				h("div", { className: "smem-toolbar", key: "bar" }, [
+					h("input", { className: "smem-search", key: "q", value: query, placeholder: "搜索文件名 / 描述 / 类型…", onChange: function (e) { setQuery(e.target.value); } }),
+					h("button", { type: "button", className: "smem-btn", key: "refresh", disabled: busy || loading, onClick: load }, "刷新"),
+					h("button", { type: "button", className: "smem-btn smem-btn-primary", key: "add", onClick: openAdd }, "+ 添加记忆"),
+				]),
+				error ? h("div", { className: "smem-err", key: "err" }, "⚠ " + error) : null,
+				notice && !error ? h("div", { className: "smem-ok", key: "ok" }, "✓ " + notice) : null,
+				formOpen
+					? h("div", { className: "smem-form", key: "form" }, [
+							h("div", { className: "smem-form-title", key: "ft" }, editingFile ? "编辑 " + editingFile : "添加记忆"),
+							h("div", { className: "smem-row", key: "cat" }, [
+								h("span", { className: "smem-label", key: "l" }, "类型："),
+								h("div", { className: "smem-chips", key: "chips" }, TYPE_ORDER.map(function (t) {
+									const meta = TYPE_META[t];
+									return h(Chip, { key: t, label: meta[0] + " " + meta[1], on: formType === t, onClick: function () { setFormType(t); } });
+								})),
+							]),
+							h("label", { className: "smem-label", key: "ln" }, "文件名（.md，留空自动 " + formType + "_note.md）"),
+							h("input", { className: "smem-input", key: "tn", value: formName, onChange: function (e) { setFormName(e.target.value); }, placeholder: "例如 project_traveler.md" }),
+							h("label", { className: "smem-label", key: "ld" }, "描述（写进 frontmatter，检索与列表都靠它）"),
+							h("input", { className: "smem-input", key: "td", value: formDesc, onChange: function (e) { setFormDesc(e.target.value); }, placeholder: "一句话说清这条记忆是什么" }),
+							h("label", { className: "smem-label", key: "lb" }, "正文（可选，frontmatter 自动生成）"),
+							h("textarea", { className: "smem-textarea", key: "tb", rows: 6, value: formBody, onChange: function (e) { setFormBody(e.target.value); }, placeholder: "要长期记住的细节" }),
+							h("div", { className: "smem-row", key: "btns" }, [
+								h("button", { type: "button", className: "smem-btn smem-btn-primary", key: "save", disabled: busy, onClick: submit }, busy ? "保存中…" : "保存"),
+								h("button", { type: "button", className: "smem-btn", key: "cancel", disabled: busy, onClick: closeForm }, "取消"),
+							]),
+						])
+					: null,
+				loading && items.length === 0
+					? h("div", { className: "smem-muted", key: "loading" }, "加载中…")
+					: filtered.length === 0
+						? h("div", { className: "smem-empty", key: "empty" },
+								items.length === 0
+									? "还没有记忆文件。对话中值得记住的事会写到这里，也可以点「添加记忆」手动写入。"
+									: "没有符合搜索条件的文件。")
+						: h("div", { className: "smem-list", key: "list" }, filtered.map(function (it) {
+								return h(Card, {
+									key: it.file,
+									item: it,
+									expanded: !!expanded[it.file],
+									deleting: deleting === it.file,
+									onToggle: function (file) {
+										const nx = {};
+										nx[file] = !expanded[file];
+										setExpanded(Object.assign({}, expanded, nx));
+									},
+									onEdit: openEdit,
+									onAskDelete: function (file) { setDeleting(file); },
+									onCancelDelete: function () { setDeleting(null); },
+									onConfirmDelete: confirmDelete,
+								});
+							})),
+			]);
+		}
+
+		const inject = ["slots", "remote"];
+
+		/**
+		 * Client 插件：$mount strict remote contribution（第三方 remote 不在
+		 * dsh-api-remotes 的固定列表里，必须自己挂），再注册设置页签。
+		 */
+		async function apply(ctx) {
+			await ctx.remote.$mount(TYPERT_REMOTE);
+			// 样式注入（参照官方 client bundle 的 data-plugin-css 约定，幂等）
+			const tagId = "sage-mem/settings.css";
+			if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId) + "]") === null) {
+				const tag = document.createElement("style");
+				tag.dataset.plugin = "sage-mem";
+				tag.dataset.pluginCss = tagId;
+				tag.textContent = CSS;
+				document.head.appendChild(tag);
+			}
+			ctx.slots.inject("settings.section", () =>
+				ctx.slots.register(
+					{ name: "settings.section", id: "sage-mem", order: 20, label: "记忆管理" },
+					(props) => react.createElement(Section, { ...props, ctx }),
+				),
+			);
+		}
+
+		exports.apply = apply;
+		exports.inject = inject;
+		return module.exports;
+	}
+});

package/lib/index.js

@@ -1,140 +1,212 @@
 /**
- * sage-mem — 记忆桥接插件。
+ * sage-mem — 文件式记忆插件（CC 原生方式）。
  *
- * 把 DSH 的事件流翻译成 sage-mem worker（fork 自 claude-mem）的 HTTP 调用：
- *   user/message        → POST /api/sessions/init        存用户 prompt
- *   tool/call + result  → POST /api/sessions/observations 捕获工具 IO
- *   turn/end            → POST /api/sessions/summarize   触发压缩
- *                         + 拉取最新记忆上下文缓存
- *   agent/session-start → 同步注入上个会话的记忆缓存（避免异步注入的时序丢失）
+ * 记忆存在本地 markdown 文件目录（frontmatter + 正文，4 类），不是数据库。
+ * host 侧两件事：
+ *   1. 按问题检索注入：system-prompt/assemble 时扫 memory 目录，按双字匹配
+ *      选相关文件，读全文注入 system prompt，让 agent 第一轮就「想起」
+ *   2. TypertRemoteService：给设置页「记忆管理」提供文件列表/读/写/删
  *
- * 注入用「上一回合结束时的缓存」而非当场 fetch：agent/session-start 时 turn
- * 组装已经开始，异步 fetch 回来再 inject 会被 inbox 消费时序吞掉。缓存在上个
- * turn/end 时已就绪，session-start 同步注入必然生效。
+ * 写入靠 AGENTS.md 的「记忆使用」规则引导 agent 自己判断 + 用文件工具写
+ * memory 目录——透明、可检查、防膨胀。无 worker、无 SQLite、无端口。
  *
- * worker 不可用时静默跳过，不阻塞 DSH 主流程。worker 进程由启动脚本管理
- * （sage-bundle 阶段统一装配，先起 worker 再起 dsh）。
- *
- * 这是 Sage 的第三道题：我下次应该怎么想 —— 跨会话沉淀事实与教训。
+ * 旧 worker 版见 git 分支 `sqlite-worker`。
  */
 
-const WORKER_URL = process.env.SAGE_MEM_WORKER_URL || 'http://127.0.0.1:37700'
-const REQUEST_TIMEOUT_MS = 3000
-const PROJECT = 'sage' // MVP：统一记忆空间；后续可按 cwd 分项目
+import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol'
+import { homedir } from 'node:os'
+import { readFile, readdir, writeFile, unlink } from 'node:fs/promises'
+import { join, basename } from 'node:path'
 
-export const name = 'sage-mem'
-export const inject = []
+const MEMORY_DIR = process.env.SAGE_MEM_DIR || join(homedir(), '.sage-mem', 'memory')
+const MAX_RESULTS = 5
+const MAX_CHARS_PER_FILE = 1500
 
-/**
- * 构造 UserMessage（手写，零依赖：dsh-llm 无法从 workspace 插件解析）。
- * source 必需——DSH 消费消息时访问 message.source.kind，纯字符串会崩。
- */
-function pluginMessage(text, plugin) {
-  return {
-    id: crypto.randomUUID(),
-    role: 'user',
-    content: [{ type: 'text', text }],
-    source: { kind: 'plugin', plugin },
-  }
+/** 提取消息文本，兼容 content 为字符串或 text-block 数组两种形态。 */
+function extractText(content) {
+  if (typeof content === 'string') return content.trim()
+  if (!Array.isArray(content)) return ''
+  return content
+    .filter(b => b && b.type === 'text' && typeof b.text === 'string')
+    .map(b => b.text)
+    .join('\n')
+    .trim()
+}
+
+/** 提取双字（2-gram）集合，中英文数字通用。 */
+function bigrams(s) {
+  const clean = String(s).toLowerCase().replace(/[^\p{L}\p{N}]+/gu, '')
+  const set = new Set()
+  for (let i = 0; i < clean.length - 1; i++) set.add(clean.slice(i, i + 2))
+  return set
 }
 
-export function apply(ctx) {
-  // tool/call 先记 callId，等 tool/result 配对后一起送 worker
-  const pendingCalls = new Map()
-  // 上个会话的记忆上下文（turn/end 时拉取，下个 session-start 同步注入）
-  let cachedContext = ''
-  // 最后一条 assistant 消息（summarize 需要）
-  let lastAssistantText = ''
-
-  async function post(path, body) {
-    try {
-      return await fetch(WORKER_URL + path, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(body),
-        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
-      })
-    } catch {
-      return null // worker 不可用：静默跳过，不阻塞 DSH
-    }
+/** query 的双字在 text 中的覆盖率（0~1），作为相关性得分。 */
+function score(query, text) {
+  const q = bigrams(query)
+  if (q.size === 0) return 0
+  const t = bigrams(text)
+  let hit = 0
+  for (const g of q) if (t.has(g)) hit++
+  return hit / q.size
+}
+
+/** 扫 memory 目录，读回全部记忆文件的正文（跳过索引与子目录）。 */
+async function scanMemoryFiles() {
+  try {
+    const entries = await readdir(MEMORY_DIR, { withFileTypes: true })
+    const names = entries
+      .filter(e => e.isFile() && e.name.endsWith('.md') && e.name !== 'MEMORY.md')
+      .map(e => e.name)
+    const loaded = await Promise.all(names.map(async (name) => {
+      try {
+        const content = await readFile(join(MEMORY_DIR, name), 'utf8')
+        return { file: name, content }
+      } catch {
+        return null
+      }
+    }))
+    return loaded.filter(Boolean)
+  } catch {
+    return []
   }
+}
 
-  function textOf(message) {
-    const blocks = Array.isArray(message?.content) ? message.content : []
-    const texts = blocks.filter(b => b?.type === 'text').map(b => b.text).filter(Boolean)
-    return texts.length ? texts.join('\n') : null
+/** 按得分选相关文件，降序取 top N。 */
+function selectRelevant(query, files) {
+  return files
+    .map(f => ({ ...f, score: score(query, f.content) }))
+    .filter(f => f.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, MAX_RESULTS)
+}
+
+/** 解析 frontmatter 的 name/description/type（兼容顶层与 metadata 嵌套两种 type）。 */
+function parseFrontmatter(content) {
+  const m = content.match(/^---\n([\s\S]*?)\n---/)
+  if (!m) return { name: '', description: '', type: '' }
+  const body = m[1]
+  const grab = (key) => {
+    const hit = body.match(new RegExp(`^${key}:\\s*(.+)$`, 'm'))
+    if (!hit) return ''
+    return hit[1].replace(/^["']|["']$/g, '').trim()
+  }
+  let type = grab('type')
+  if (!type) {
+    const nested = body.match(/^metadata:\s*\n(?:\s+[^\n]+\n)*?\s+type:\s*(\S+)/m)
+    if (nested) type = nested[1]
   }
+  return { name: grab('name'), description: grab('description'), type }
+}
+
+/** 防路径穿越：只取 basename，且必须在 memory 目录内（.md，排除索引）。 */
+function safeName(raw) {
+  const name = basename(String(raw || ''))
+  if (!name || !name.endsWith('.md') || name === 'MEMORY.md') return null
+  return name
+}
 
-  // 1. 会话启动：同步注入上个会话的记忆缓存
-  // 注意：事件名是 'agent/session-start'（'emit' 只是分发模式，不是事件名）
-  ctx.on('agent/session-start', (payload) => {
-    const { agent } = payload
-    if (cachedContext) {
-      agent.inject(pluginMessage(`以下是过往会话沉淀的记忆（sage-mem 检索）：\n\n${cachedContext}`, 'sage-mem'))
-    }
+/**
+ * 手动 @Remote marker 注册（Node 24 不解析装饰器语法，手写 decorator context）。
+ */
+function markRemote(cls, method, exportName) {
+  const instance = Object.create(cls.prototype)
+  Remote(exportName)(undefined, {
+    kind: 'method',
+    name: method,
+    private: false,
+    static: false,
+    addInitializer(fn) {
+      fn.call(instance)
+    },
   })
+}
 
-  // 2. 会话内事件：写入记忆
-  ctx.on('session/event', (subject, event) => {
-    const sessionId = subject?.header?.id
-    if (!sessionId) return
-
-    switch (event.type) {
-      case 'user/message': {
-        const text = textOf(event.data)
-        if (!text) return
-        post('/api/sessions/init', { contentSessionId: sessionId, project: PROJECT, prompt: text })
-        break
-      }
-      case 'assistant/message': {
-        // payload 是 { turn, step, message, usage }，message 嵌套一层
-        const text = textOf(event.data?.message)
-        if (text) lastAssistantText = text
-        break
-      }
-      case 'tool/call': {
-        pendingCalls.set(event.data.callId, { name: event.data.name, arguments: event.data.arguments })
-        break
-      }
-      case 'tool/result': {
-        const message = event.data?.message
-        const call = pendingCalls.get(message?.callId)
-        pendingCalls.delete(message?.callId)
-        if (!call) return
-        post('/api/sessions/observations', {
-          contentSessionId: sessionId,
-          tool_name: call.name,
-          tool_input: call.arguments,
-          tool_response: message.content,
-        })
-        break
-      }
-      case 'turn/end': {
-        post('/api/sessions/summarize', {
-          contentSessionId: sessionId,
-          ...(lastAssistantText ? { last_assistant_message: lastAssistantText } : {}),
+export class MemoryGateway extends TypertRemoteService {
+  constructor(ctx) {
+    super(ctx, 'memory')
+
+    // 按问题检索注入：system-prompt/assemble 是异步 waterfall，监听器可 await。
+    // 从 agent.session 拿当前 user message，扫 memory 目录按双字匹配选相关
+    // 文件，读全文作为动态 context 段注入——让 agent 第一轮就「想起」。
+    ctx.on('system-prompt/assemble', async (assembly, context, next) => {
+      const assembled = await next()
+      try {
+        const agent = context?.agent
+        const session = agent?.session
+        if (!session || typeof session.deriveMessages !== 'function') return assembled
+        const messages = [...session.deriveMessages()]
+        const lastUser = messages.reverse().find(m => m?.role === 'user')
+        const text = extractText(lastUser?.content)
+        if (!text || text.length < 2) return assembled
+
+        const files = await scanMemoryFiles()
+        const relevant = selectRelevant(text, files)
+        if (relevant.length === 0) return assembled
+
+        const parts = relevant.map(f => {
+          const body = f.content.length > MAX_CHARS_PER_FILE
+            ? f.content.slice(0, MAX_CHARS_PER_FILE) + '\n…（截断）'
+            : f.content
+          return `### ${f.file}\n${body}`
         })
-        // 元认知捕获：回合最后一条 assistant 输出（装了 sage-meta 时是自检输出）
-        // 作为带标记的 observation 发，worker 压缩时按 lesson 类型引导归类
-        if (lastAssistantText) {
-          post('/api/sessions/observations', {
-            contentSessionId: sessionId,
-            tool_name: 'meta/self-check',
-            tool_input: { turn: event.data?.turn },
-            tool_response: lastAssistantText,
-          })
+
+        return {
+          ...assembled,
+          contexts: [...(assembled.contexts ?? []), {
+            name: 'sage-mem:recall',
+            order: 1000,
+            text: `以下是与你当前问题相关的历史记忆（文件式，来自 ${MEMORY_DIR}）：\n\n${parts.join('\n\n')}`,
+          }],
         }
-        // 拉取最新记忆上下文，缓存给下一个会话注入
-        fetch(`${WORKER_URL}/api/context/inject?project=${encodeURIComponent(PROJECT)}`, {
-          signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
-        })
-          .then(r => (r.ok ? r.text() : null))
-          .then(text => {
-            if (text) cachedContext = text
-          })
-          .catch(() => {})
-        break
+      } catch {
+        return assembled
       }
-    }
-  })
+    })
+  }
+
+  /** 列出 memory 目录全部记忆文件（文件名 + 类型 + 描述 + 大小）。 */
+  async listFiles() {
+    const files = await scanMemoryFiles()
+    return files.map(f => {
+      const meta = parseFrontmatter(f.content)
+      return {
+        file: f.file,
+        type: meta.type || 'reference',
+        description: meta.description || '',
+        size: f.content.length,
+      }
+    })
+  }
+
+  /** 读单个记忆文件全文。 */
+  async readFile(name) {
+    const safe = safeName(name)
+    if (!safe) throw new Error('sage-mem: invalid file name')
+    const content = await readFile(join(MEMORY_DIR, safe), 'utf8')
+    return { name: safe, content }
+  }
+
+  /** 写（新增或覆盖）单个记忆文件。 */
+  async writeFile(name, content) {
+    const safe = safeName(name)
+    if (!safe) throw new Error('sage-mem: invalid file name')
+    await writeFile(join(MEMORY_DIR, safe), String(content ?? ''), 'utf8')
+    return { ok: true, file: safe }
+  }
+
+  /** 删除单个记忆文件。 */
+  async deleteFile(name) {
+    const safe = safeName(name)
+    if (!safe) throw new Error('sage-mem: invalid file name')
+    await unlink(join(MEMORY_DIR, safe))
+    return { ok: true }
+  }
 }
+
+markRemote(MemoryGateway, 'listFiles', 'listFiles')
+markRemote(MemoryGateway, 'readFile', 'readFile')
+markRemote(MemoryGateway, 'writeFile', 'writeFile')
+markRemote(MemoryGateway, 'deleteFile', 'deleteFile')
+
+export default MemoryGateway

package/lib/typert.host.js

@@ -0,0 +1,90 @@
+/**
+ * sage-mem — 手写 strict typert host manifest（对齐官方生成文件格式）。
+ * typert-loader 在插件挂载时读 package.json 的 exports["./typert"]，
+ * import 本文件并把 TYPERT 注册进 ctx.typert.local（strict 定义）。
+ * schema 必须是 zod v4 实例（typert-loader 校验 "_zod" in schema）。
+ */
+import { z } from 'zod'
+
+const fileNameSchema = z.string()
+const fileContentSchema = z.string()
+
+const fileSchema = z.object({
+	'file': z.string().readonly(),
+	'type': z.string().readonly(),
+	'description': z.string().readonly(),
+	'size': z.number().readonly(),
+}).readonly()
+
+const listResultSchema = z.array(fileSchema)
+const readResultSchema = z.object({
+	'name': z.string().readonly(),
+	'content': z.string().readonly(),
+}).readonly()
+const writeResultSchema = z.object({
+	'ok': z.boolean().readonly(),
+	'file': z.string().readonly(),
+}).readonly()
+const deleteResultSchema = z.object({
+	'ok': z.boolean().readonly(),
+}).readonly()
+
+export const TYPERT = {
+	package: 'sage-mem',
+	face: 'host',
+	schemas: [],
+	invocations: [
+		{
+			id: 'sage-mem#memory/listFiles',
+			service: 'memory',
+			namespace: 'memory',
+			method: 'listFiles',
+			invocation: { kind: 'direct' },
+			parameters: [],
+			result: { mode: 'strict', typeSymbol: 'sage-mem/types#FileList', schema: listResultSchema },
+			sourceLocation: { "file": "workspace/sage-mem/lib/index.js", "line": 1, "column": 1 },
+		},
+		{
+			id: 'sage-mem#memory/readFile',
+			service: 'memory',
+			namespace: 'memory',
+			method: 'readFile',
+			invocation: { kind: 'direct' },
+			parameters: [
+				{ name: 'name', wire: 'name', source: 'json', codec: { mode: 'strict', typeSymbol: 'sage-mem/types#FileName', schema: fileNameSchema } },
+			],
+			result: { mode: 'strict', typeSymbol: 'sage-mem/types#FileContent', schema: readResultSchema },
+			sourceLocation: { "file": "workspace/sage-mem/lib/index.js", "line": 1, "column": 1 },
+		},
+		{
+			id: 'sage-mem#memory/writeFile',
+			service: 'memory',
+			namespace: 'memory',
+			method: 'writeFile',
+			invocation: { kind: 'direct' },
+			parameters: [
+				{ name: 'name', wire: 'name', source: 'json', codec: { mode: 'strict', typeSymbol: 'sage-mem/types#FileName', schema: fileNameSchema } },
+				{ name: 'content', wire: 'content', source: 'json', codec: { mode: 'strict', typeSymbol: 'sage-mem/types#FileContent', schema: fileContentSchema } },
+			],
+			result: { mode: 'strict', typeSymbol: 'sage-mem/types#WriteResult', schema: writeResultSchema },
+			sourceLocation: { "file": "workspace/sage-mem/lib/index.js", "line": 1, "column": 1 },
+		},
+		{
+			id: 'sage-mem#memory/deleteFile',
+			service: 'memory',
+			namespace: 'memory',
+			method: 'deleteFile',
+			invocation: { kind: 'direct' },
+			parameters: [
+				{ name: 'name', wire: 'name', source: 'json', codec: { mode: 'strict', typeSymbol: 'sage-mem/types#FileName', schema: fileNameSchema } },
+			],
+			result: { mode: 'strict', typeSymbol: 'sage-mem/types#DeleteResult', schema: deleteResultSchema },
+			sourceLocation: { "file": "workspace/sage-mem/lib/index.js", "line": 1, "column": 1 },
+		},
+	],
+	model: {
+		"services": [],
+		"events": [],
+		"objects": [],
+	},
+}

package/package.json

@@ -1,25 +1,44 @@
 {
   "name": "sage-mem",
-  "description": "Memory plugin for DeepSeek Harness (DSH) — cross-session memory with Chinese-first full-text search",
-  "version": "0.1.2",
+  "description": "File-based memory plugin for DeepSeek Harness (DSH) — cross-session memory in transparent markdown files",
+  "version": "0.4.0",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
     ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./typert": "./lib/typert.host.js",
     "./package.json": "./package.json"
   },
   "files": [
     "lib/index.js",
-    "cordis.patch.yml"
+    "lib/client.js",
+    "lib/typert.host.js",
+    "cordis.patch.yml",
+    "NOTICE"
   ],
-  "license": "MIT",
+  "license": "Apache-2.0",
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-runtime"
+      ]
     }
   },
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1"
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-locale": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-runtime": "^0.1.0-rc.6",
+    "react": "^18.0.0"
   },
   "repository": {
     "type": "git",