dsh-lite-memory 0.2.2 → 0.2.4

package/README.md

@@ -16,7 +16,7 @@ Lightweight memory for the DeepSeek Harness. Nothing in the system prompt, nothi
 | 场景 | 行为 |
 | --- | --- |
 | **L0** 你明确要求「记住这个」 | 立即写盘，一条确认行 |
-| **L1** 它发现有跨会话价值的经验 | 一行灰字 `可记「X」` + 一个 `保留` 按钮；不点就永远不写 |
+| **L1** 它发现有跨会话价值的经验 | 一行灰字 `memory · keep "X"?` + 一个 `keep` 按钮；不写问句、不用你打字，不点就永远不写，48 小时内不重复 |
 | **L2** 常识、一次性参数、凭据的值 | 永不写入 |
 
 触发词：`记住`、`记一下`、`上次`、`规范`、`约定`、`路径`、`凭据怎么取`。
@@ -24,14 +24,14 @@ Lightweight memory for the DeepSeek Harness. Nothing in the system prompt, nothi
 | 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 |
+| **L1** it spots something worth keeping | one muted line `memory · keep "X"?` with a single `keep` button — never a question, no typing, nothing written unless you click, at most once per two days |
 | **L2** common sense, one-off parameters, credential values | never written |
 
 ## 点一下就存 / One click, no turn
 
-「保留」是同源直写：不产生消息、不动输入框、不打断当前回复。按钮变 `已保存` 就结束了。
+`keep` 是同源直写：不产生消息、不动输入框、不打断当前回复。按钮变 `kept` 就结束了。自动写入的行尾有个 `✕`，点它就把刚才那条移入归档。
 
-`保留` 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.
+`keep` writes straight to disk from the page: no message, no extra model turn, the input box untouched. The button turns into `kept` and that is the whole interaction. An auto-saved line ends with `✕`: click it and that entry moves to the archive.
 
 ## 为什么轻 / Why it stays light
 

package/TRIGGERS.md

@@ -4,8 +4,8 @@
 
 | 档 | 谁发起 | 什么时候 | 存不存 | 用户看到什么 |
 | --- | --- | --- | --- | --- |
-| L0 | 用户 | 说「记住 / 以后 / 别用 / 下次」这类话 | 直接存 | `记忆 · 已存「X」` |
-| L1 | 模型 | 用户没说，但这经验跨会话有用 | 点了才存 | `可记「X」` + 「保留」按钮 |
+| L0 | 用户 | 说「记住 / 以后 / 别用 / 下次」这类话 | 直接存 | `memory · saved "X"` + `✕` |
+| L1 | 模型 | 用户没说，但这经验跨会话有用 | 点了才存 | `memory · keep "X"?` + `keep` 按钮 |
 | L2 | — | 常识、一次性参数、临时路径 | 不存 | 无 |
 
 ## 什么时候触发
@@ -13,8 +13,8 @@
 模型不会常驻读记忆。触发全靠工具描述里的触发词，命中才调。
 
 - 查：用户说「上次 / 之前 / 记住过 / 规范 / 约定 / 路径 / 凭据怎么取」，或要做的事像是在这个项目里做过。
-- 写：用户明确要求；或用户对某条建议点了「保留」。
-- 建议：一条经验能跨会话复用、又只存在于用户嘴里（偏好、惯例、踩过的坑），且同一项目 24 小时内没建议过。
+- 写：用户明确要求；用户自己的话已经是长期规则（「以后都这样 / 别再 X」）时直接存，不先问；或用户对某条建议点了「保留」。
+- 建议：一条经验能跨会话复用、又只存在于用户嘴里（偏好、惯例、踩过的坑），且同一项目 48 小时内没建议过。只出按钮，不写「要不要记」这种问句——问句要用户打字，按钮不要。
 - 不写：`1+1=2` 这种常识、一次性任务参数、能从仓库直接读到的正文；凭据只记位置与调用方式。
 
 ## 触发后长什么样
@@ -22,19 +22,19 @@
 每次调用只占一行、灰色、12px：
 
 ```
-· 记忆 · 命中 2 条 · 引用 96 字
-· 记忆 · 无匹配
-· 记忆 · 已存「插件市场条目规范」
-· 可记「提交前先跑文案 lint」        [保留]
-· 记忆 · 未建议：今天已经建议过「插件市场条目规范」
-· 记忆 · 已归档「插件市场条目规范」
+· memory · 2 hits · 96 chars
+· memory · no hits
+· memory · saved "插件市场条目规范"              ✕
+· memory · keep "提交前先跑文案 lint"           [keep]
+· memory · skipped
+· memory · dropped "插件市场条目规范"
 ```
 
-「保留」按钮只在 `可记` 那一行出现。点一下直接写盘：不产生消息、不动输入框、不占用下一轮对话，按钮变 `已保存` 并禁用。同源写盘通道不通时才退回旧路——插入 `保留记忆「X」` 并排队，至少不丢这条建议，按钮显示 `已保留`。不点就什么都不发生，那行过一会儿只是一段灰色历史。
+`keep` 按钮只在建议行出现。点一下直接写盘：不产生消息、不动输入框、不占用下一轮对话，按钮变 `kept` 并禁用。同源写盘通道不通时才退回旧路——插入 `保留记忆「X」` 并排队，至少不丢这条建议。自动写入的行尾带 `✕`，点了把那一条移入归档（不删文件，可从归档取回）。不点就什么都不发生，那行过一会儿只是一段灰色历史。
 
 ## 频率与退让
 
-- 建议：同一项目 24 小时一条；同一主题存过就不再建议。
+- 建议：同一项目 48 小时一条、一次对话最多一条；同一主题存过就不再建议。
 - 结果：搜索最多 4 条、400 字；全文只在 `memory_read` 里出现。
 - 用户说「别记」→ `memory_forget` 归档，不删文件。
 - 拒绝三次后仍反复建议，说明触发词太宽：收窄 `memory_suggest` 的描述，而不是加状态。

package/client.js

@@ -6,47 +6,63 @@ window.__ModuleLoader__.load({
 
     /** One muted line per memory call: a summary, never the payload. */
     const RUNNING = {
-      memory_save: '记忆 · 写入中',
-      memory_suggest: '记忆 · 判断中',
-      memory_search: '记忆 · 检索中',
-      memory_read: '记忆 · 读取中',
-      memory_forget: '记忆 · 归档中',
+      memory_save: 'memory · saving',
+      memory_suggest: 'memory · checking',
+      memory_search: 'memory · searching',
+      memory_read: 'memory · reading',
+      memory_forget: 'memory · dropping',
     };
 
-    const LABELS = { idle: '保留', saving: '保存中', saved: '已保存', kept: '已保留' };
+    const KEEP = { idle: 'keep', saving: 'saving', saved: 'kept', kept: '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 KEEP_STYLE = { 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_STYLE, opacity: 0.9, cursor: 'pointer' };
+    const KEEP_OFF = { ...KEEP_STYLE, opacity: 0.45, cursor: 'default' };
+    const DROP = { flex: '0 0 auto', border: 'none', background: 'transparent', color: 'inherit', padding: '0 2px', fontSize: '12px', lineHeight: '18px', opacity: 0.55, cursor: 'pointer' };
 
-    /** 结果文本已经是中文，这里只取第一行。 */
     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 '记忆 · 失败';
+      if (block.error !== undefined) return 'memory · stopped';
+      if (block.isError === true) return 'memory · failed';
       return null;
     };
 
     const firstLine = (value) => (typeof value === 'string' ? value.split('\n')[0] : null);
 
+    /** 结果行里带标题时把它取出来，用于点按钮后原路回传。 */
+    const quoted = (value) => {
+      const match = typeof value === 'string' ? /"([^"]+)"/.exec(value) : null;
+      return match ? match[1] : null;
+    };
+
+    const post = (payload) => {
+      if (typeof fetch !== 'function') return Promise.resolve(null);
+      return fetch('/lite-memory/keep', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(payload),
+      })
+        .then((response) => (response.ok ? response.json() : null))
+        .catch(() => 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] ?? '记忆'));
+      return h('div', { 'data-tool': props.toolName, style: ROW }, h('span', { style: DOT }, '·'), h('span', { style: LABEL }, line ?? RUNNING[props.toolName] ?? 'memory'));
     };
 
-    /** 建议行只有一个「保留」：点击直接写盘。 */
+    /** 建议行：一个「keep」按钮，点了直接写盘。 */
     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 label = firstLine(text) ?? RUNNING.memory_suggest;
+      const title = quoted(text);
       const cwd = typeof props.cwd === 'string' ? props.cwd : '';
       const actions = props.inputActions;
       const canKeep = Boolean(title) && Boolean(cwd) && state === 'idle';
@@ -67,28 +83,39 @@ window.__ModuleLoader__.load({
           }
         };
         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'));
+        post({ op: 'keep', title, cwd }).then((value) => setState(value && value.ok ? 'saved' : 'kept'));
       };
       const button = title
-        ? h('button', { type: 'button', onClick: keep, disabled: !canKeep, 'aria-label': '保留这条记忆', style: canKeep ? KEEP_ON : KEEP_OFF }, LABELS[state] ?? LABELS.idle)
+        ? h('button', { type: 'button', onClick: keep, disabled: !canKeep, 'aria-label': '保留这条记忆', style: canKeep ? KEEP_ON : KEEP_OFF }, KEEP[state] ?? KEEP.idle)
         : null;
       return h('div', { 'data-tool': props.toolName, style: ROW }, h('span', { style: DOT }, '·'), h('span', { style: LABEL }, label), button);
     };
 
+    /** 自动写入行：一个「✕」，点了把它移入归档。 */
+    const SavedRow = (props) => {
+      const [state, setState] = React.useState('idle');
+      const text = props.phase === 'preparing' ? null : settledText(props.block);
+      const title = quoted(text);
+      const cwd = typeof props.cwd === 'string' ? props.cwd : '';
+      const canDrop = Boolean(title) && Boolean(cwd) && state === 'idle';
+      const drop = () => {
+        if (!canDrop) return;
+        setState('saving');
+        post({ op: 'undo', title, cwd }).then((value) => setState(value && value.ok ? 'dropped' : 'idle'));
+      };
+      const label = state === 'dropped' ? 'memory · dropped' : firstLine(text) ?? RUNNING.memory_save;
+      const button = title && state !== 'dropped' ? h('button', { type: 'button', onClick: drop, disabled: !canDrop, 'aria-label': '删除这条记忆', style: DROP }, '✕') : 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']) {
+        for (const name of ['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));
+        ctx.slots.inject('tool.call.toolview', () => ctx.slots.register({ name: 'tool.call.toolview', key: 'memory_save' }, SavedRow));
       },
     };
   },

package/index.js

@@ -66,7 +66,7 @@ function readJsonBody(req, limit = 8192) {
   });
 }
 
-/** 「保留」按钮的唯一入口：只认已经建议过的那条，不接收任意正文。 */
+/** 「保留」和「✕」的唯一入口：保留只认已经建议过的那条，删除只按标题找已有条目。 */
 function keepHandler(webServer) {
   return async (req, res) => {
     if (req.method !== 'POST') return sendJson(res, 405, { ok: false, reason: '只接受 POST' });
@@ -75,7 +75,8 @@ function keepHandler(webServer) {
       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: '未知操作' });
+    const known = pathname === REMOTE_PATH + '/keep' || pathname === REMOTE_PATH + '/undo';
+    if (!known) return sendJson(res, 404, { ok: false, reason: '未知操作' });
     let body;
     try {
       body = await readJsonBody(req);
@@ -86,6 +87,16 @@ function keepHandler(webServer) {
     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);
+    if (body.op === 'undo' || pathname === REMOTE_PATH + '/undo') {
+      const record = loadIndex(scope).entries.find((item) => item.title === title);
+      if (!record) return sendJson(res, 404, { ok: false, reason: '没有这条记忆' });
+      try {
+        forget(scope, record.id);
+        return sendJson(res, 200, { ok: true, title: record.title, id: record.id });
+      } catch (error) {
+        return sendJson(res, 400, { ok: false, reason: error instanceof Error ? error.message : '删除失败' });
+      }
+    }
     const draft = findSuggestion(scope, title);
     if (!draft) return sendJson(res, 404, { ok: false, reason: '没有待保留的建议' });
     try {
@@ -145,7 +156,7 @@ export function apply(ctx) {
 
   ctx.effect(() => tools.register({
     name: 'memory_save',
-    description: `保存一条记忆。仅在用户明确要求记住，或用户确认保留时才调用。用户发「保留记忆「X」」时，用当时那条建议的内容调用本工具。${NOTES}`,
+    description: `保存一条记忆。用户明确说「记住」时直接调用；用户自己的话已经是长期规则（「以后都这样」「别再 X」）时也直接调用，不要先问。用户点了「保留」或发「保留记忆「X」」时，用那条建议的内容调用。${NOTES}`,
     parameters: SAVE_PARAMS,
     output: {
       schema: {
@@ -160,7 +171,7 @@ export function apply(ctx) {
       },
       render: (value) => [{
         type: 'text',
-        text: `记忆 · 已存「${value.title}」${value.merged ? '（并入了同主题条目）' : ''}`,
+        text: value.merged ? `memory · merged "${value.title}"` : `memory · saved "${value.title}"`,
       }],
     },
     execute: async (args, execution) => {
@@ -172,7 +183,7 @@ export function apply(ctx) {
 
   ctx.effect(() => tools.register({
     name: 'memory_suggest',
-    description: `对一条值得长期保留、但用户没有明说的经验提出保存建议。用户点「保留」才保存，不点就不保存。每次会话最多用一次；同一项目 24 小时内不会重复建议。${NOTES}`,
+    description: `对一条用户没说、但跨会话还有用的经验提出保存建议。调用后对话里出现一个「保留」按钮，用户点了才保存。不要用问句征询「要不要记」，那要用户打字；按钮不打扰对话。一次对话最多建议一条，问自己「下次会话还得靠它吗」，不确定就别建议。${NOTES}`,
     parameters: SUGGEST_PARAMS,
     output: {
       schema: {
@@ -187,7 +198,7 @@ export function apply(ctx) {
       },
       render: (value) => [{
         type: 'text',
-        text: value.asked ? `可记「${value.title}」` : `记忆 · 未建议：${value.reason ?? ''}`,
+        text: value.asked ? `memory · keep "${value.title}"?` : 'memory · skipped',
       }],
     },
     execute: async (args, execution) => {
@@ -216,7 +227,7 @@ export function apply(ctx) {
       },
       render: (value) => [{
         type: 'text',
-        text: value.count === 0 ? '记忆 · 无匹配' : `记忆 · 命中 ${value.count} 条 · 引用 ${value.chars} 字\n${value.index}`,
+        text: value.count === 0 ? 'memory · no hits' : `memory · ${value.count} hits · ${value.chars} chars\n${value.index}`,
       }],
     },
     execute: async (args, execution) => {
@@ -264,7 +275,7 @@ export function apply(ctx) {
       },
       render: (value) => [{
         type: 'text',
-        text: `记忆 · 已归档「${value.title}」`,
+        text: `memory · dropped "${value.title}"`,
       }],
     },
     execute: async (args, execution) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-lite-memory",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "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",

package/store.js

@@ -13,7 +13,7 @@ export const LIMITS = {
   totalBytes: 512 * 1024,
   titleChars: 40,
   summaryChars: 60,
-  suggestionWindowMs: 24 * 60 * 60 * 1000,
+  suggestionWindowMs: 48 * 60 * 60 * 1000,
 };
 
 /** Strings that mean "this is a credential", never a memory. */
@@ -220,14 +220,14 @@ export function forget(scope, id) {
   return record;
 }
 
-/** Why a suggestion is refused: one per day per project, and never for a saved topic. */
+/** Why a suggestion is refused: one per two days 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}」` };
+  if (recent) return { ok: false, reason: `48 小时内已建议过「${recent.title}」` };
   return { ok: true };
 }