dsh-lite-memory 0.0.0-stage → 0.2.2

package/LICENSE

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

package/README.md

@@ -1,3 +1,62 @@
-# Temporary Holding Version
+# dsh-lite-memory
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**零常驻记忆。命中才读，没命中一分上下文都不花。**
+**Memory that costs nothing until the moment you need it.**
+
+---
+
+## 它是什么 / What it is
+
+给 DeepSeek Harness 的轻量记忆：不写系统提示、不逐轮注入、不扫描文件。记忆只在两种时刻出现——你说「记一下」，或者它命中了一条查过的内容。
+
+Lightweight memory for the DeepSeek Harness. Nothing in the system prompt, nothing injected per turn. Memory appears at exactly two moments: you ask it to remember, or a query matches something already stored.
+
+## 触发方式 / Triggers
+
+| 场景 | 行为 |
+| --- | --- |
+| **L0** 你明确要求「记住这个」 | 立即写盘，一条确认行 |
+| **L1** 它发现有跨会话价值的经验 | 一行灰字 `可记「X」` + 一个 `保留` 按钮；不点就永远不写 |
+| **L2** 常识、一次性参数、凭据的值 | 永不写入 |
+
+触发词：`记住`、`记一下`、`上次`、`规范`、`约定`、`路径`、`凭据怎么取`。
+
+| Case | Behaviour |
+| --- | --- |
+| **L0** you ask it to remember | written immediately, one confirmation line |
+| **L1** it spots something worth keeping | one muted line `可记「X」` with a single `保留` button — nothing is written unless you click |
+| **L2** common sense, one-off parameters, credential values | never written |
+
+## 点一下就存 / One click, no turn
+
+「保留」是同源直写：不产生消息、不动输入框、不打断当前回复。按钮变 `已保存` 就结束了。
+
+`保留` writes straight to disk from the page: no message, no extra model turn, the input box untouched. The button turns into `已保存` and that is the whole interaction.
+
+## 为什么轻 / Why it stays light
+
+- **0 依赖**，存储层无定时器、无监听、无网络，只有同步单文件写。
+- 搜索最多 4 条、400 字；正文只在 `memory_read` 里出现，全文永不进上下文。
+- 同标题自动合并；90 天未用只留 `id + 标题`；超 200 条或 512 KB 转 `archive/`，文件从不删除。
+- 一个项目一个目录，项目之间互相看不见。
+
+- **Zero dependencies.** The store has no timers, no listeners, no network — just synchronous single-file writes.
+- Search returns at most 4 hits and 400 characters. Full text only appears in `memory_read`.
+- Same title merges. Unused for 90 days drops to `id + title`. Over 200 entries or 512 KB archives instead of piling up. Files are never deleted.
+- One directory per project, so projects never see each other's notes.
+
+## 安装 / Install
+
+Plugin Manager 里搜 `dsh-lite-memory` 直接装；或 `npm pack` 后用 Plugin Manager 安装生成的 `.tgz`。
+
+Install from the DSH Plugin Manager (search `dsh-lite-memory`), or `npm pack` and install the resulting `.tgz` through it.
+
+## 工具 / Tools
+
+`memory_save` · `memory_suggest` · `memory_search` · `memory_read` · `memory_forget`
+
+完整触发规则见 [TRIGGERS.md](TRIGGERS.md)。 / Full trigger rules: [TRIGGERS.md](TRIGGERS.md).
+
+## License
+
+MIT

package/TRIGGERS.md

@@ -0,0 +1,47 @@
+# 触发与展示
+
+三档。档位决定「谁说了算」和「什么时候出现在对话里」。
+
+| 档 | 谁发起 | 什么时候 | 存不存 | 用户看到什么 |
+| --- | --- | --- | --- | --- |
+| L0 | 用户 | 说「记住 / 以后 / 别用 / 下次」这类话 | 直接存 | `记忆 · 已存「X」` |
+| L1 | 模型 | 用户没说，但这经验跨会话有用 | 点了才存 | `可记「X」` + 「保留」按钮 |
+| L2 | — | 常识、一次性参数、临时路径 | 不存 | 无 |
+
+## 什么时候触发
+
+模型不会常驻读记忆。触发全靠工具描述里的触发词，命中才调。
+
+- 查：用户说「上次 / 之前 / 记住过 / 规范 / 约定 / 路径 / 凭据怎么取」，或要做的事像是在这个项目里做过。
+- 写：用户明确要求；或用户对某条建议点了「保留」。
+- 建议：一条经验能跨会话复用、又只存在于用户嘴里（偏好、惯例、踩过的坑），且同一项目 24 小时内没建议过。
+- 不写：`1+1=2` 这种常识、一次性任务参数、能从仓库直接读到的正文；凭据只记位置与调用方式。
+
+## 触发后长什么样
+
+每次调用只占一行、灰色、12px：
+
+```
+· 记忆 · 命中 2 条 · 引用 96 字
+· 记忆 · 无匹配
+· 记忆 · 已存「插件市场条目规范」
+· 可记「提交前先跑文案 lint」        [保留]
+· 记忆 · 未建议：今天已经建议过「插件市场条目规范」
+· 记忆 · 已归档「插件市场条目规范」
+```
+
+「保留」按钮只在 `可记` 那一行出现。点一下直接写盘：不产生消息、不动输入框、不占用下一轮对话，按钮变 `已保存` 并禁用。同源写盘通道不通时才退回旧路——插入 `保留记忆「X」` 并排队，至少不丢这条建议，按钮显示 `已保留`。不点就什么都不发生，那行过一会儿只是一段灰色历史。
+
+## 频率与退让
+
+- 建议：同一项目 24 小时一条；同一主题存过就不再建议。
+- 结果：搜索最多 4 条、400 字；全文只在 `memory_read` 里出现。
+- 用户说「别记」→ `memory_forget` 归档，不删文件。
+- 拒绝三次后仍反复建议，说明触发词太宽：收窄 `memory_suggest` 的描述，而不是加状态。
+
+## 新会话为什么不会乱
+
+- 记忆只在工具结果里出现，从不进 system prompt，也从不伪造用户消息。
+- 结果行永远是「记忆 · …」，模型能分清这是历史笔记，不是用户本轮要求。
+- 摘要必须是名词短语；「你要…」「请…」这类指令式摘要会被拒绝写入。
+- 存储按项目目录哈希隔离，别的项目看不到。

package/client.js

@@ -0,0 +1,95 @@
+window.__ModuleLoader__.load({
+  id: 'dsh-lite-memory',
+  factory(require) {
+    const React = require('react');
+    const h = React.createElement;
+
+    /** One muted line per memory call: a summary, never the payload. */
+    const RUNNING = {
+      memory_save: '记忆 · 写入中',
+      memory_suggest: '记忆 · 判断中',
+      memory_search: '记忆 · 检索中',
+      memory_read: '记忆 · 读取中',
+      memory_forget: '记忆 · 归档中',
+    };
+
+    const LABELS = { idle: '保留', saving: '保存中', saved: '已保存', kept: '已保留' };
+    const ROW = { display: 'flex', alignItems: 'center', gap: '6px', padding: '1px 0', fontSize: '12px', lineHeight: '1.6', opacity: 0.7 };
+    const DOT = { flex: '0 0 auto', opacity: 0.8 };
+    const LABEL = { minWidth: 0, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' };
+    const KEEP = { flex: '0 0 auto', border: '1px solid currentColor', background: 'transparent', color: 'inherit', borderRadius: '999px', padding: '0 8px', fontSize: '12px', lineHeight: '18px' };
+    const KEEP_ON = { ...KEEP, opacity: 0.9, cursor: 'pointer' };
+    const KEEP_OFF = { ...KEEP, opacity: 0.45, cursor: 'default' };
+
+    /** 结果文本已经是中文，这里只取第一行。 */
+    const settledText = (block) => {
+      if (block === undefined || block === null || !('kind' in block)) return null;
+      const content = Array.isArray(block.content) ? block.content : [];
+      for (const item of content) {
+        if (item !== null && item.type === 'text' && typeof item.text === 'string' && item.text.length > 0) return item.text;
+      }
+      if (block.error !== undefined) return '记忆 · 已中止';
+      if (block.isError === true) return '记忆 · 失败';
+      return null;
+    };
+
+    const firstLine = (value) => (typeof value === 'string' ? value.split('\n')[0] : null);
+
+    const Row = (props) => {
+      const line = props.phase === 'preparing' ? null : firstLine(settledText(props.block));
+      return h('div', { 'data-tool': props.toolName, style: ROW }, h('span', { style: DOT }, '·'), h('span', { style: LABEL }, line ?? RUNNING[props.toolName] ?? '记忆'));
+    };
+
+    /** 建议行只有一个「保留」：点击直接写盘。 */
+    const SuggestRow = (props) => {
+      const [state, setState] = React.useState('idle');
+      const text = props.phase === 'preparing' ? null : settledText(props.block);
+      const label = firstLine(text) ?? RUNNING.memory_suggest ?? '记忆';
+      const match = typeof text === 'string' && text.startsWith('可记「') ? /「([^」]+)」/.exec(text) : null;
+      const title = match ? match[1] : null;
+      const cwd = typeof props.cwd === 'string' ? props.cwd : '';
+      const actions = props.inputActions;
+      const canKeep = Boolean(title) && Boolean(cwd) && state === 'idle';
+      const keep = () => {
+        if (!canKeep) return;
+        setState('saving');
+        /** 写盘通道不通时退回一条普通消息，至少不丢这条建议。 */
+        const fallback = () => {
+          try {
+            const message = `保留记忆「${title}」`;
+            const span = actions && typeof actions.captureInsertion === 'function' ? actions.captureInsertion() : null;
+            const inserted = span && actions && typeof actions.insertText === 'function' ? actions.insertText(message, span) : false;
+            if (inserted === false && actions && typeof actions.setDraft === 'function') actions.setDraft(message);
+            if (actions && typeof actions.submit === 'function') actions.submit();
+            setState('kept');
+          } catch {
+            setState('idle');
+          }
+        };
+        if (typeof fetch !== 'function') return fallback();
+        fetch('/lite-memory/keep', {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ title, cwd }),
+        })
+          .then((response) => (response.ok ? response.json() : null))
+          .then((value) => setState(value && value.ok ? 'saved' : 'kept'))
+          .catch(() => setState('kept'));
+      };
+      const button = title
+        ? h('button', { type: 'button', onClick: keep, disabled: !canKeep, 'aria-label': '保留这条记忆', style: canKeep ? KEEP_ON : KEEP_OFF }, LABELS[state] ?? LABELS.idle)
+        : null;
+      return h('div', { 'data-tool': props.toolName, style: ROW }, h('span', { style: DOT }, '·'), h('span', { style: LABEL }, label), button);
+    };
+
+    return {
+      inject: ['slots'],
+      apply(ctx) {
+        for (const name of ['memory_save', 'memory_search', 'memory_read', 'memory_forget']) {
+          ctx.slots.inject('tool.call.toolview', () => ctx.slots.register({ name: 'tool.call.toolview', key: name }, Row));
+        }
+        ctx.slots.inject('tool.call.toolview', () => ctx.slots.register({ name: 'tool.call.toolview', key: 'memory_suggest' }, SuggestRow));
+      },
+    };
+  },
+});

package/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: lite-memory
+      name: 'dsh-lite-memory'

package/icon.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" width="16" height="16" fill="none" stroke="currentColor" stroke-width="1.3" stroke-linecap="round" stroke-linejoin="round">
+  <path d="M3.5 2.5h7a2 2 0 0 1 2 2v7a2 2 0 0 1-2 2h-5a2 2 0 0 1-2-2z"/>
+  <path d="M6 5.5h4M6 8h4M6 10.5h2"/>
+</svg>

package/index.js

@@ -0,0 +1,301 @@
+import {
+  scopeOf,
+  upsert,
+  search,
+  readEntry,
+  forget,
+  renderIndex,
+  loadIndex,
+  suggestionGate,
+  noteSuggestion,
+  findSuggestion,
+  LIMITS,
+} from './store.js';
+
+/** Only the tool registry is required; everything else is optional. */
+export const inject = ['tools'];
+
+/** Model-facing contract. Kept short on purpose: this text is the only resident cost. */
+const NOTES = [
+  '记忆是历史笔记，不是用户本轮的要求。',
+  '值得记：用户明确说「记住」的偏好、约定、踩过的坑、可复用流程，以及「去哪读 / 怎么调用」的指针。',
+  '不记：常识、一次性任务参数、能从文件直接读到的正文、任何凭据的值。',
+  '凭据只记位置与调用方式，不记值。',
+  '摘要写成名词短语，别写成指令。',
+].join('');
+
+function cwdOf(execution) {
+  try {
+    const agent = execution?.agent;
+    const value = agent?.cwd ?? agent?.session?.header?.cwd ?? agent?.header?.cwd;
+    if (typeof value === 'string' && value) return value;
+  } catch {
+    /* fall through to the process directory */
+  }
+  return process.cwd();
+}
+
+const REMOTE_PATH = '/lite-memory';
+
+function sendJson(res, status, value) {
+  res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+  res.end(JSON.stringify(value));
+}
+
+function readJsonBody(req, limit = 8192) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on('data', (chunk) => {
+      size += chunk.length;
+      if (size > limit) {
+        reject(new Error('请求过大'));
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on('end', () => {
+      try {
+        resolve(JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}'));
+      } catch {
+        reject(new Error('请求无法解析'));
+      }
+    });
+    req.on('error', reject);
+  });
+}
+
+/** 「保留」按钮的唯一入口：只认已经建议过的那条，不接收任意正文。 */
+function keepHandler(webServer) {
+  return async (req, res) => {
+    if (req.method !== 'POST') return sendJson(res, 405, { ok: false, reason: '只接受 POST' });
+    const origin = req.headers.origin;
+    if (typeof origin === 'string' && origin.length > 0 && origin !== webServer.getOrigin()) {
+      return sendJson(res, 403, { ok: false, reason: '来源不符' });
+    }
+    const pathname = String(req.url || '').split('?')[0];
+    if (pathname !== REMOTE_PATH + '/keep') return sendJson(res, 404, { ok: false, reason: '未知操作' });
+    let body;
+    try {
+      body = await readJsonBody(req);
+    } catch (error) {
+      return sendJson(res, 400, { ok: false, reason: error instanceof Error ? error.message : '请求无法解析' });
+    }
+    const cwd = typeof body.cwd === 'string' ? body.cwd : '';
+    const title = typeof body.title === 'string' ? body.title : '';
+    if (cwd.length === 0 || title.length === 0) return sendJson(res, 400, { ok: false, reason: '请求不完整' });
+    const scope = scopeOf(cwd);
+    const draft = findSuggestion(scope, title);
+    if (!draft) return sendJson(res, 404, { ok: false, reason: '没有待保留的建议' });
+    try {
+      const saved = upsert(scope, draft);
+      return sendJson(res, 200, { ok: true, title: saved.record.title, id: saved.record.id });
+    } catch (error) {
+      return sendJson(res, 400, { ok: false, reason: error instanceof Error ? error.message : '保存失败' });
+    }
+  };
+}
+
+const SAVE_PARAMS = {
+  type: 'object',
+  properties: {
+    title: { type: 'string', description: `标题，名词短语，不超过 ${LIMITS.titleChars} 字` },
+    summary: { type: 'string', description: `一句话摘要，名词短语，不超过 ${LIMITS.summaryChars} 字` },
+    body: { type: 'string', description: '正文 markdown。只写指针与要点，不抄录长文档' },
+    kind: { type: 'string', enum: ['preference', 'convention', 'procedure', 'pointer', 'pitfall', 'credential_hint', 'note'], description: '条目类型' },
+    tags: { type: 'array', items: { type: 'string' }, description: '最多 5 个标签' },
+  },
+  required: ['title', 'summary'],
+  additionalProperties: false,
+};
+
+const SUGGEST_PARAMS = SAVE_PARAMS;
+
+const SEARCH_PARAMS = {
+  type: 'object',
+  properties: {
+    query: { type: 'string', description: '要查的主题；用用户原话里的词' },
+    limit: { type: 'integer', minimum: 1, maximum: 6, description: '最多返回几条，默认 4' },
+  },
+  required: ['query'],
+  additionalProperties: false,
+};
+
+const READ_PARAMS = {
+  type: 'object',
+  properties: { id: { type: 'string', description: '记忆 id，来自搜索结果' } },
+  required: ['id'],
+  additionalProperties: false,
+};
+
+const FORGET_PARAMS = {
+  type: 'object',
+  properties: { id: { type: 'string', description: '要移入归档的记忆 id' } },
+  required: ['id'],
+  additionalProperties: false,
+};
+
+function text(blocks) {
+  return blocks.map((block) => (block.type === 'text' ? block.text : JSON.stringify(block)));
+}
+
+export function apply(ctx) {
+  const tools = ctx.tools;
+
+  ctx.effect(() => tools.register({
+    name: 'memory_save',
+    description: `保存一条记忆。仅在用户明确要求记住，或用户确认保留时才调用。用户发「保留记忆「X」」时，用当时那条建议的内容调用本工具。${NOTES}`,
+    parameters: SAVE_PARAMS,
+    output: {
+      schema: {
+        type: 'object',
+        properties: {
+          id: { type: 'string' },
+          title: { type: 'string' },
+          merged: { type: 'boolean' },
+        },
+        required: ['id', 'title', 'merged'],
+        additionalProperties: false,
+      },
+      render: (value) => [{
+        type: 'text',
+        text: `记忆 · 已存「${value.title}」${value.merged ? '（并入了同主题条目）' : ''}`,
+      }],
+    },
+    execute: async (args, execution) => {
+      const scope = scopeOf(cwdOf(execution));
+      const saved = upsert(scope, args);
+      return { id: saved.record.id, title: saved.record.title, merged: saved.merged };
+    },
+  }), 'lite-memory: memory_save');
+
+  ctx.effect(() => tools.register({
+    name: 'memory_suggest',
+    description: `对一条值得长期保留、但用户没有明说的经验提出保存建议。用户点「保留」才保存，不点就不保存。每次会话最多用一次；同一项目 24 小时内不会重复建议。${NOTES}`,
+    parameters: SUGGEST_PARAMS,
+    output: {
+      schema: {
+        type: 'object',
+        properties: {
+          asked: { type: 'boolean' },
+          title: { type: 'string' },
+          reason: { type: 'string' },
+        },
+        required: ['asked', 'title'],
+        additionalProperties: false,
+      },
+      render: (value) => [{
+        type: 'text',
+        text: value.asked ? `可记「${value.title}」` : `记忆 · 未建议：${value.reason ?? ''}`,
+      }],
+    },
+    execute: async (args, execution) => {
+      const scope = scopeOf(cwdOf(execution));
+      const gate = suggestionGate(scope, args.title);
+      if (!gate.ok) return { asked: false, title: String(args.title ?? ''), reason: gate.reason };
+      noteSuggestion(scope, args, 'asked');
+      return { asked: true, title: String(args.title ?? '') };
+    },
+  }), 'lite-memory: memory_suggest');
+
+  ctx.effect(() => tools.register({
+    name: 'memory_search',
+    description: `按关键词检索已有记忆，返回标题与一句话摘要（最多 4 条）。用户提到「记住过 / 上次 / 规范 / 约定 / 路径 / 凭据怎么取」时先查这里。命中后再用 memory_read 取正文。${NOTES}`,
+    parameters: SEARCH_PARAMS,
+    output: {
+      schema: {
+        type: 'object',
+        properties: {
+          count: { type: 'integer' },
+          chars: { type: 'integer' },
+          index: { type: 'string' },
+        },
+        required: ['count', 'chars', 'index'],
+        additionalProperties: false,
+      },
+      render: (value) => [{
+        type: 'text',
+        text: value.count === 0 ? '记忆 · 无匹配' : `记忆 · 命中 ${value.count} 条 · 引用 ${value.chars} 字\n${value.index}`,
+      }],
+    },
+    execute: async (args, execution) => {
+      const scope = scopeOf(cwdOf(execution));
+      const hits = search(scope, args.query, args.limit ?? 4);
+      const rendered = renderIndex(hits);
+      return { count: hits.length, chars: rendered.chars, index: rendered.text };
+    },
+  }), 'lite-memory: memory_search');
+
+  ctx.effect(() => tools.register({
+    name: 'memory_read',
+    description: '读取一条记忆的正文。只在摘要不足以回答时才调用。',
+    parameters: READ_PARAMS,
+    output: {
+      schema: {
+        type: 'object',
+        properties: {
+          id: { type: 'string' },
+          title: { type: 'string' },
+          body: { type: 'string' },
+        },
+        required: ['id', 'title', 'body'],
+        additionalProperties: false,
+      },
+      render: (value) => text([{ type: 'text', text: value.body }]),
+    },
+    execute: async (args, execution) => {
+      const scope = scopeOf(cwdOf(execution));
+      const { record, body } = readEntry(scope, args.id);
+      return { id: record.id, title: record.title, body };
+    },
+  }), 'lite-memory: memory_read');
+
+  ctx.effect(() => tools.register({
+    name: 'memory_forget',
+    description: '把一条记忆移入归档。用户说「别记这个 / 删掉那条」时调用；归档不删除文件。',
+    parameters: FORGET_PARAMS,
+    output: {
+      schema: {
+        type: 'object',
+        properties: { id: { type: 'string' }, title: { type: 'string' } },
+        required: ['id', 'title'],
+        additionalProperties: false,
+      },
+      render: (value) => [{
+        type: 'text',
+        text: `记忆 · 已归档「${value.title}」`,
+      }],
+    },
+    execute: async (args, execution) => {
+      const scope = scopeOf(cwdOf(execution));
+      const record = forget(scope, args.id);
+      return { id: record.id, title: record.title };
+    },
+  }), 'lite-memory: memory_forget');
+
+  /** 「保留」走同源路由：点击只写盘，不产生消息，也不打断对话。 */
+  const mountRoute = (holder) => {
+    const webServer = typeof holder.get === 'function' ? holder.get('webServer', false) : holder.webServer;
+    if (!webServer || typeof webServer.register !== 'function' || typeof webServer.getOrigin !== 'function') return;
+    holder.effect(() => webServer.register({ kind: 'prefix', path: REMOTE_PATH, handler: keepHandler(webServer) }), 'lite-memory: keep route');
+  };
+  if (typeof ctx.inject === 'function') ctx.inject(['webServer'], (scope) => mountRoute(scope));
+  else mountRoute(ctx);
+
+  /** Read-only summary for the Client row: how big the store already is. */
+  ctx.effect(() => {
+    globalThis.__liteMemoryStats = (cwd) => {
+      try {
+        const scope = scopeOf(cwd ?? process.cwd());
+        const index = loadIndex(scope);
+        return { scope: scope.key, count: index.entries.length, bytes: index.totalBytes ?? 0 };
+      } catch {
+        return { scope: '', count: 0, bytes: 0 };
+      }
+    };
+    return () => {
+      delete globalThis.__liteMemoryStats;
+    };
+  }, 'lite-memory: stats');
+}

package/locale/en.json

@@ -0,0 +1,4 @@
+{
+  "meta.title": "Lite Memory",
+  "meta.description": "Zero resident storage. Reads on a hit; costs nothing when nothing matches."
+}

package/locale/zh.json

@@ -0,0 +1,4 @@
+{
+  "meta.title": "轻记忆",
+  "meta.description": "零常驻存储。命中才读，未命中不占上下文。"
+}

package/package.json

@@ -1,6 +1,60 @@
 {
   "name": "dsh-lite-memory",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.2",
+  "description": "On-demand memory for the DeepSeek Harness: nothing in the system prompt, one muted line only when something is saved, hit or suggested.",
+  "type": "module",
+  "main": "index.js",
+  "engines": {
+    "dsh": ">=0.1.5"
+  },
+  "scripts": {
+    "test": "node test/store.test.mjs"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "store.js",
+    "client.js",
+    "cordis.patch.yml",
+    "locale",
+    "icon.svg",
+    "README.md",
+    "TRIGGERS.md",
+    "LICENSE",
+    "test"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-conversation"
+      ]
+    }
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "memory",
+    "deepseek-harness"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/regrevia/dsh-lite-memory.git"
+  },
+  "homepage": "https://github.com/regrevia/dsh-lite-memory#readme",
+  "bugs": {
+    "url": "https://github.com/regrevia/dsh-lite-memory/issues"
+  },
+  "author": "regrevia",
+  "license": "MIT"
+}

package/store.js

@@ -0,0 +1,276 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+
+/**
+ * Hard limits. They are the whole reason this plugin stays small for years:
+ * nothing is ever allowed to grow without pushing the oldest entry to archive/.
+ */
+export const LIMITS = {
+  entries: 200,
+  entryBytes: 4096,
+  totalBytes: 512 * 1024,
+  titleChars: 40,
+  summaryChars: 60,
+  suggestionWindowMs: 24 * 60 * 60 * 1000,
+};
+
+/** Strings that mean "this is a credential", never a memory. */
+const SECRET_PATTERNS = [
+  /sk-[A-Za-z0-9_-]{16,}/,
+  /gh[pousr]_[A-Za-z0-9]{20,}/,
+  /AKIA[0-9A-Z]{16}/,
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----/,
+  /(?:password|passwd|secret|token|api[_-]?key|access[_-]?key)\s*[:=]\s*\S{6,}/i,
+  /[A-Za-z0-9+/]{60,}={0,2}/,
+];
+
+/** A summary is a noun phrase. An imperative turns a note into an instruction. */
+const IMPERATIVE = /^(?:你要|你得|你必须|请|务必|必须|记得|记住|别忘了|do not|don't|please|you (?:must|should|need))/i;
+
+export function memoryRoot() {
+  const home = process.env.DSH_HOME || path.join(os.homedir(), '.dsh');
+  return path.join(home, 'lite-memory');
+}
+
+/** One store per project directory, so projects never see each other. */
+export function scopeOf(cwd) {
+  const abs = path.resolve(cwd || process.cwd());
+  const hash = crypto.createHash('sha1').update(abs).digest('hex').slice(0, 8);
+  const label = path.basename(abs).replace(/[^\w.-]+/g, '-').slice(0, 32) || 'root';
+  return { key: `${label}-${hash}`, dir: path.join(memoryRoot(), `${label}-${hash}`), cwd: abs };
+}
+
+function readJson(file, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function writeAtomic(file, text) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, text);
+  fs.renameSync(tmp, file);
+}
+
+export function detectSecret(text) {
+  const hit = SECRET_PATTERNS.find((re) => re.test(String(text || '')));
+  return hit ? hit.source : null;
+}
+
+export function normalizeText(value, max) {
+  return String(value ?? '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, max);
+}
+
+export function validSummary(summary) {
+  const text = normalizeText(summary, LIMITS.summaryChars);
+  if (!text) return { ok: false, reason: '摘要为空' };
+  if (IMPERATIVE.test(text)) return { ok: false, reason: '摘要必须写成名词短语，不能写成指令' };
+  return { ok: true, text };
+}
+
+function entryFile(scope, id) {
+  return path.join(scope.dir, 'entries', `${id}.md`);
+}
+
+export function loadIndex(scope) {
+  const file = path.join(scope.dir, 'index.json');
+  const data = readJson(file, null);
+  if (!data || !Array.isArray(data.entries)) return { version: 1, scope: scope.key, entries: [], suggestions: [] };
+  if (!Array.isArray(data.suggestions)) data.suggestions = [];
+  return data;
+}
+
+export function saveIndex(scope, index) {
+  index.version = 1;
+  index.scope = scope.key;
+  index.cwd = scope.cwd;
+  index.updated = new Date().toISOString();
+  index.totalBytes = index.entries.reduce((sum, item) => sum + (item.bytes || 0), 0);
+  writeAtomic(path.join(scope.dir, 'index.json'), JSON.stringify(index, null, 2));
+}
+
+/** Oldest and least used first; archive keeps the file, it never deletes. */
+function archiveEntry(scope, index, entry) {
+  try {
+    const from = entryFile(scope, entry.id);
+    const to = path.join(scope.dir, 'archive', `${entry.id}.md`);
+    fs.mkdirSync(path.dirname(to), { recursive: true });
+    if (fs.existsSync(from)) fs.renameSync(from, to);
+  } catch {
+    /* an unreadable entry is still dropped from the index */
+  }
+  index.entries = index.entries.filter((item) => item.id !== entry.id);
+}
+
+export function trimIndex(scope, index) {
+  const byStaleness = [...index.entries].sort((a, b) => {
+    const rank = (item) => (item.lastUsed || item.updated || item.created || '');
+    return rank(a).localeCompare(rank(b));
+  });
+  while (index.entries.length > LIMITS.entries) archiveEntry(scope, index, byStaleness.shift());
+  let total = index.entries.reduce((sum, item) => sum + (item.bytes || 0), 0);
+  while (total > LIMITS.totalBytes && byStaleness.length > 0) {
+    const victim = byStaleness.shift();
+    if (!index.entries.some((item) => item.id === victim.id)) continue;
+    total -= victim.bytes || 0;
+    archiveEntry(scope, index, victim);
+  }
+}
+
+function similarity(a, b) {
+  const words = (text) => new Set(normalizeText(text, 400).toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((w) => w.length > 1));
+  const left = words(a);
+  const right = words(b);
+  if (left.size === 0 || right.size === 0) return 0;
+  let shared = 0;
+  for (const word of left) if (right.has(word)) shared += 1;
+  return shared / Math.max(left.size, right.size);
+}
+
+/**
+ * Save or merge one memory. A repeat of an existing topic updates it and counts
+ * the merge instead of adding a row, which is what keeps a long-lived store tidy.
+ */
+export function upsert(scope, draft) {
+  const title = normalizeText(draft.title, LIMITS.titleChars);
+  if (!title) throw new Error('标题为空');
+  const summary = validSummary(draft.summary);
+  if (!summary.ok) throw new Error(summary.reason);
+  const body = String(draft.body ?? '').trim();
+  if (body.length > LIMITS.entryBytes) throw new Error(`正文超过 ${LIMITS.entryBytes} 字，请精简或拆成指针`);
+  const asSecret = detectSecret(`${title}\n${summary.text}\n${body}`);
+  if (asSecret) throw new Error(`检出疑似凭据，未保存（${asSecret}）。凭据只记位置与调用方式`);
+
+  const index = loadIndex(scope);
+  const now = new Date().toISOString();
+  const existing = index.entries.find((item) => item.title === title) || index.entries.find((item) => similarity(item.summary, summary.text) > 0.8);
+  const id = existing ? existing.id : `mem_${Date.now().toString(36)}${crypto.randomBytes(2).toString('hex')}`;
+  const record = {
+    id,
+    title,
+    summary: summary.text,
+    kind: draft.kind || 'note',
+    tags: Array.isArray(draft.tags) ? draft.tags.map((tag) => normalizeText(tag, 20)).filter(Boolean).slice(0, 5) : [],
+    created: existing ? existing.created : now,
+    updated: now,
+    lastUsed: now,
+    hits: existing ? existing.hits || 0 : 0,
+    merges: existing ? (existing.merges || 0) + 1 : 0,
+    bytes: Buffer.byteLength(body, 'utf8'),
+  };
+  writeAtomic(entryFile(scope, id), body);
+  if (existing) index.entries = index.entries.map((item) => (item.id === id ? record : item));
+  else index.entries.push(record);
+  index.suggestions = (index.suggestions || []).filter((item) => item.title !== title).slice(-19);
+  trimIndex(scope, index);
+  saveIndex(scope, index);
+  return { record, merged: Boolean(existing) };
+}
+
+export function search(scope, query, limit = 4) {
+  const index = loadIndex(scope);
+  const terms = normalizeText(query, 200)
+    .toLowerCase()
+    .split(/[^\p{L}\p{N}]+/u)
+    .filter((word) => word.length > 1);
+  const scored = index.entries.map((item) => {
+    const hay = `${item.title} ${item.summary} ${(item.tags || []).join(' ')}`.toLowerCase();
+    let score = 0;
+    for (const term of terms) if (hay.includes(term)) score += term.length > 2 ? 2 : 1;
+    if (terms.length > 0 && score === 0) score = similarity(item.title, query) > 0.5 ? 1 : 0;
+    return { item, score };
+  });
+  const hits = scored.filter((row) => row.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
+  if (hits.length > 0) {
+    const now = new Date().toISOString();
+    for (const hit of hits) {
+      hit.item.hits = (hit.item.hits || 0) + 1;
+      hit.item.lastUsed = now;
+    }
+    saveIndex(scope, index);
+  }
+  return hits.map((row) => row.item);
+}
+
+export function readEntry(scope, id) {
+  const index = loadIndex(scope);
+  const record = index.entries.find((item) => item.id === id);
+  if (!record) throw new Error(`没有这条记忆：${id}`);
+  const body = fs.readFileSync(entryFile(scope, record.id), 'utf8');
+  record.lastUsed = new Date().toISOString();
+  record.hits = (record.hits || 0) + 1;
+  saveIndex(scope, index);
+  return { record, body };
+}
+
+export function forget(scope, id) {
+  const index = loadIndex(scope);
+  const record = index.entries.find((item) => item.id === id);
+  if (!record) throw new Error(`没有这条记忆：${id}`);
+  archiveEntry(scope, index, record);
+  saveIndex(scope, index);
+  return record;
+}
+
+/** Why a suggestion is refused: one per day per project, and never for a saved topic. */
+export function suggestionGate(scope, title) {
+  const index = loadIndex(scope);
+  const text = normalizeText(title, LIMITS.titleChars);
+  if (index.entries.some((item) => item.title === text)) return { ok: false, reason: '这条已经存过' };
+  const now = Date.now();
+  const recent = index.suggestions.find((item) => now - Date.parse(item.at) < LIMITS.suggestionWindowMs);
+  if (recent) return { ok: false, reason: `今天已经建议过「${recent.title}」` };
+  return { ok: true };
+}
+
+export function noteSuggestion(scope, draft, decision = 'asked') {
+  const source = typeof draft === 'string' ? { title: draft } : draft;
+  const title = normalizeText(source.title, LIMITS.titleChars);
+  const payload = {
+    title,
+    summary: normalizeText(source.summary, LIMITS.summaryChars),
+    body: String(source.body ?? ''),
+    kind: source.kind || 'note',
+    tags: Array.isArray(source.tags) ? source.tags.map((tag) => normalizeText(tag, 20)).filter(Boolean).slice(0, 5) : [],
+  };
+  const index = loadIndex(scope);
+  index.suggestions = [
+    ...(index.suggestions || []),
+    { title, at: new Date().toISOString(), decision, draft: payload },
+  ].slice(-20);
+  saveIndex(scope, index);
+}
+
+/** 待保留的那条建议；没有就返回 null（已过期、已存下或从未建议过）。 */
+export function findSuggestion(scope, title) {
+  const index = loadIndex(scope);
+  const text = normalizeText(title, LIMITS.titleChars);
+  const item = (index.suggestions || []).find((entry) => entry.title === text && entry.decision === 'asked');
+  if (!item) return null;
+  return item.draft ?? { title: text };
+}
+
+/** The compact index handed to the model: one noun-phrase line per entry, hard capped. */
+export function renderIndex(entries, budget = 400) {
+  const staleMs = 90 * 24 * 60 * 60 * 1000;
+  const now = Date.now();
+  const lines = [];
+  let used = 0;
+  for (const item of entries) {
+    const last = Date.parse(item.lastUsed || item.updated || item.created || '') || now;
+    const stale = now - last > staleMs;
+    const line = stale ? `- ${item.id} ${item.title}` : `- ${item.id} ${item.title}｜${item.summary}`;
+    if (used + line.length > budget) break;
+    lines.push(line);
+    used += line.length + 1;
+  }
+  return { text: lines.join('\n'), chars: used };
+}

package/test/store.test.mjs

@@ -0,0 +1,65 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import * as store from '../store.js';
+
+const home = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-'));
+process.env.DSH_HOME = home;
+
+const scope = store.scopeOf('/tmp/project-a');
+const other = store.scopeOf('/tmp/project-b');
+const draft = { title: '插件市场条目规范', summary: '市场上传指南的位置与要点', body: '见 UPLOAD-GUIDE.md', kind: 'pointer', tags: ['marketplace'] };
+
+const first = store.upsert(scope, draft);
+assert.equal(first.merged, false);
+assert.equal(store.loadIndex(scope).entries.length, 1);
+
+const second = store.upsert(scope, { ...draft, summary: '市场上传指南的位置与要点（更新）' });
+assert.equal(second.merged, true);
+assert.equal(second.record.id, first.record.id);
+assert.equal(store.loadIndex(scope).entries.length, 1);
+assert.equal(store.loadIndex(scope).entries[0].merges, 1);
+
+assert.deepEqual(store.search(scope, '插件市场').map((item) => item.id), [first.record.id]);
+assert.deepEqual(store.search(scope, '量子力学'), []);
+assert.deepEqual(store.loadIndex(other).entries, []);
+
+assert.throws(() => store.upsert(scope, { title: 'x', summary: '你要记得用 tab 缩进' }), /名词短语/);
+assert.throws(() => store.upsert(scope, { title: 'y', summary: '凭据位置', body: 'ghp_abcdefghijklmnopqrstuvwxyz0123456789' }), /凭据/);
+
+const read = store.readEntry(scope, first.record.id);
+assert.match(read.body, /UPLOAD-GUIDE/);
+assert.ok(store.loadIndex(scope).entries[0].hits >= 2);
+
+assert.equal(store.suggestionGate(scope, '插件市场条目规范').ok, false);
+store.noteSuggestion(scope, '提交前先跑 lint');
+assert.equal(store.suggestionGate(scope, '另一条').ok, false);
+store.upsert(scope, { title: '提交前先跑 lint', summary: '交付前的文案检查步骤' });
+assert.equal(store.suggestionGate(scope, '新的建议').ok, true);
+
+const old = store.upsert(scope, { title: '很久没用到的条目', summary: '三个月没命中', body: 'x' });
+const index = store.loadIndex(scope);
+index.entries = index.entries.map((item) =>
+  item.id === old.record.id ? { ...item, lastUsed: new Date(Date.now() - 400 * 86400000).toISOString() } : item,
+);
+store.saveIndex(scope, index);
+const stale = store.loadIndex(scope).entries.find((item) => item.id === old.record.id);
+const rendered = store.renderIndex([stale]);
+assert.equal(rendered.text.includes('｜'), false);
+assert.ok(rendered.text.includes(old.record.title));
+
+const forgotten = store.forget(scope, first.record.id);
+assert.equal(forgotten.title, draft.title);
+assert.equal(store.loadIndex(scope).entries.some((item) => item.id === first.record.id), false);
+assert.ok(fs.existsSync(path.join(scope.dir, 'archive', `${first.record.id}.md`)));
+
+for (let i = 0; i < 240; i += 1) {
+  store.upsert(scope, { title: `条目 ${i}`, summary: `第 ${i} 条`, body: 'x' });
+}
+const trimmed = store.loadIndex(scope);
+assert.ok(trimmed.entries.length <= store.LIMITS.entries);
+assert.ok(trimmed.totalBytes <= store.LIMITS.totalBytes);
+
+fs.rmSync(home, { recursive: true, force: true });
+console.log('store: 16 checks passed');