dsh-lite-memory 0.18.41 → 0.18.43

package/docs/RELEASE-0.18.42.md

@@ -0,0 +1,26 @@
+# 0.18.42：回执会自己过期，使用次数说真话
+
+## 问题
+
+- 回执（最近操作记录）只在「接受候选」时清过期项。不产候选的层会一直留着过期回执，
+  状态文件只增不减；`receipts` 上限 256 条，过期数据还可能把新回执挤掉。
+- 记录里的 `hits` 字段从来没人加：写的时候是 0，之后一直是 0，既占状态字节又不反映
+  真实使用，面板也没法解释「这条被用过几次」。
+
+## 改法
+
+- 抽出 `pruneReceiptList(rows, now)`：按 7 天 TTL 过滤并截到上限。每次状态写入
+  （`applyFlat`）顺手调用，不再依赖候选审批；`pruneReceipts` 改为复用同一函数。
+- `hits` 改为「真实交付并记账的回合数」：只有 `markUsed` / 回合收尾记账才加一；
+  检索、阅读、注入正文仍是纯读，不碰 `hits`，只在需要时补 `lastUsed`。
+- `everUsed` 与 `lastUsed` 的写入合并进同一次保存判断：第一次被用到时标记一定落盘，
+  十分钟防抖只约束 `lastUsed` 的重复回写。
+- 没有新增常驻提示、没有改召回顺序与注入字节，状态只减不增。
+
+## 验证
+
+- `test/store.test.mjs`：预置一条过期、一条新鲜回执，任意一次普通写入后过期项被清掉。
+- `test/store.test.mjs`：检索/阅读后 `hits` 不变、`lastUsed` 不变。
+- `test/recall.test.mjs`：送达记账后 `hits === 1`，再次记账累加到 2，不受防抖影响。
+- `test/contract.test.mjs`：注入正文本身不写 `hits`；交付过的卡片在下一轮开头记一次。
+- 全量 `npm test` 通过。

package/docs/RELEASE-0.18.43.md

@@ -0,0 +1,18 @@
+# 0.18.43：回执上限从 256 降到 64
+
+## 问题
+
+回执只用于同一 `operationId` 的重放保护，重试都发生在当下；按 7 天 TTL 叠加 256 条
+上限，热点层实测单层回执 35 KB。面板并不读这份列表，`state.receipts` 纯粹是防重
+数据，留 256 条等于白占状态体积。
+
+## 改法
+
+- `LIMITS.receipts` 256 → 64。仍按 7 天 TTL 过期，仍在每次状态写入时清理。
+- 单个热点层实测回执体积从 35.7 KB 降到约 9 KB；重放窗口覆盖当下重试与并发收尾，
+  不涉及历史查询。
+
+## 验证
+
+- 全量 `npm test` 通过（含回执过期清理、按 `operationId` 重放两条回归）。
+- 线上层 `DSH-0ea3b310` 下一次写入即截到 64 条。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-lite-memory",
-  "version": "0.18.41",
+  "version": "0.18.43",
   "description": "On-demand memory for the DeepSeek Harness: nothing resident, at most three small cards on a real hit, bodies read on demand.",
   "type": "module",
   "main": "index.js",

package/state.js

@@ -232,7 +232,8 @@ export const LIMITS = {
   suggestionTtlMs: 48 * 60 * 60 * 1000,
   pending: 20,
   pendingBytes: 64 * 1024,
-  receipts: 256,
+  /** 回执只用于同一操作的重放保护，重试都发生在当下；256 条会白占几十 KB。 */
+  receipts: 64,
   receiptTtlMs: 7 * 24 * 60 * 60 * 1000,
   suppressions: 64,
   suppressionTtlMs: 7 * 24 * 60 * 60 * 1000,

package/store.js

@@ -246,7 +246,8 @@ function applyFlat(scope, draft, index) {
   for (const record of index.archived || []) next.push(fromFlat(coldStored(scope, record), 'archived'));
   draft.entries = next;
   draft.candidates = Array.isArray(index.suggestions) ? JSON.parse(JSON.stringify(index.suggestions)) : [];
-  draft.receipts = Array.isArray(index.receipts) ? JSON.parse(JSON.stringify(index.receipts)) : [];
+  /** 每次写入顺手清过期回执：只有接受候选才清的话，不产候选的层会一直留着过期的。 */
+  draft.receipts = pruneReceiptList(Array.isArray(index.receipts) ? JSON.parse(JSON.stringify(index.receipts)) : []);
   draft.suppressions = Array.isArray(index.suppressions) ? JSON.parse(JSON.stringify(index.suppressions)) : [];
   draft.conflicts = Array.isArray(index.conflicts) ? JSON.parse(JSON.stringify(index.conflicts)) : [];
   draft.lastSuggestedAt = typeof index.lastSuggestedAt === 'string' ? index.lastSuggestedAt : draft.lastSuggestedAt || '';
@@ -1513,7 +1514,7 @@ function usedStale(record, now) {
  * 真正被搜到/读过才算用过：只回写 lastUsed，不动 hits，也不改正文。
  * 抢不到锁或并发冲突都吞掉——这个是提示字段，不该让检索/阅读失败。
  */
-function touchUsed(scope, ids) {
+function touchUsed(scope, ids, countHit = false) {
   const wanted = new Set((ids || []).filter((id) => typeof id === 'string' && id));
   if (wanted.size === 0) return;
   try {
@@ -1524,8 +1525,13 @@ function touchUsed(scope, ids) {
       let changed = false;
       for (const record of index.entries) {
         if (!wanted.has(record.id)) continue;
+        /** 检索/阅读只补 lastUsed，不记 hits：只有真正交付给模型的记账才算一次使用。 */
+        if (countHit) {
+          record.hits = (Number(record.hits) || 0) + 1;
+          changed = true;
+        }
+        /** 第一次被真用到必须记下来，哪怕刚创建、还没过 lastUsed 的防抖门槛。 */
         if (record.everUsed !== true) {
-          /** 第一次被真用到必须记下来，哪怕刚创建、还没过 lastUsed 的防抖门槛。 */
           record.everUsed = true;
           changed = true;
         }
@@ -1611,7 +1617,7 @@ export function markUsed(scope, ids) {
   const wanted = (Array.isArray(ids) ? ids : []).filter((id) => typeof id === 'string' && id);
   if (!wanted.length) return;
   for (const source of [scope, globalScope()]) {
-    try { touchUsed(source, wanted); } catch { /* lastUsed 只是提示 */ }
+    try { touchUsed(source, wanted, true); } catch { /* lastUsed 只是提示 */ }
   }
 }
 
@@ -2062,12 +2068,15 @@ function suppressionOf(index, fingerprint) {
   return '';
 }
 
-function pruneReceipts(index) {
-  const now = Date.now();
-  index.receipts = (index.receipts || []).filter((item) => {
-    const at = Date.parse(item.at || '');
+function pruneReceiptList(rows, now = Date.now()) {
+  return (Array.isArray(rows) ? rows : []).filter((item) => {
+    const at = Date.parse(item && item.at ? item.at : '');
     return Number.isFinite(at) && now - at < LIMITS.receiptTtlMs;
   }).slice(-LIMITS.receipts);
+}
+
+function pruneReceipts(index) {
+  index.receipts = pruneReceiptList(index.receipts);
   return index.receipts;
 }
 

package/test/contract.test.mjs

@@ -542,6 +542,7 @@ const sig1 = new AbortController().signal;
 const hitsBefore = store.loadIndex(store.scopeOf(cwd)).entries.find((item) => item.id === hintedRow.id).hits;
 await preStep({ agent: recallAgent, signal: sig1, turn: '2' }, pass('又弹钥匙串窗口了，怎么弄', 'h1'));
 const hintText = recall.text({ agent: recallAgent, signal: sig1 });
+assert.equal(store.loadIndex(store.scopeOf(cwd)).entries.find((item) => item.id === hintedRow.id).hits, hitsBefore, '注入正文本身是纯读，不写 hits');
 assert.doesNotMatch(hintText, /mem_[a-z0-9]{6,}/, '召回卡只给标题，不给内部编号');
 assert.match(hintText, /需要细节用 memory_read/);
 sessionCwds.set('session-recall', cwd);
@@ -559,7 +560,7 @@ const missReceipt = await call('/lite-memory/overview', { sessionId: 'session-re
 assert.ok(['no_overlap', 'needs_context'].includes(missReceipt.body.current.recall.reason), '没提醒时也说明依据');
 assert.equal(missReceipt.body.current.recall.cards, 0);
 const hitsAfter = store.loadIndex(store.scopeOf(cwd)).entries.find((item) => item.id === hintedRow.id).hits;
-assert.equal(hitsAfter, hitsBefore);
+assert.equal(hitsAfter, hitsBefore + 1, '交付过的卡片在下一轮开头记一次使用');
 
 const sig2 = new AbortController().signal;
 await preStep({ agent: recallAgent, signal: sig2, turn: '3' }, pass('周四晚上发版要注意什么', 'h2'));

package/test/recall.test.mjs

@@ -1017,6 +1017,7 @@ console.log('recall.test.mjs: ok');
   const probe = save(scope, { title: '量子纠缠咖啡机', tags: ['记账'], summary: '只有送达才记 lastUsed' });
   const lastUsedOf = () => store.locateByTitle(scope, '量子纠缠咖啡机').record.lastUsed;
   const usedOf = () => store.locateByTitle(scope, '量子纠缠咖啡机').record.used;
+  const hitsOf = () => store.locateByTitle(scope, '量子纠缠咖啡机').record.hits;
   assert.equal(usedOf(), false, '新建但没被用过的条目不能算读过');
   const baseline = lastUsedOf();
   const runtime = boot();
@@ -1030,5 +1031,9 @@ console.log('recall.test.mjs: ok');
   assert.equal(lastUsedOf(), baseline, '送达也不在 provider 路径上写盘');
   runtime.handlers.get('agent/turn-stopping').at(-1)({ signal: hitSignal });
   assert.equal(usedOf(), true, '送达并记账后「读过」标记跟着成立');
+  assert.equal(hitsOf(), 1, '送达一次记一次使用次数');
+  const id = store.locateByTitle(scope, '量子纠缠咖啡机').record.id;
+  store.markUsed(scope, [id]);
+  assert.equal(hitsOf(), 2, '再次记账继续累加，不受 lastUsed 防抖影响');
   assert.equal(store.locateByTitle(scope, '量子纠缠咖啡机').record.id, probe.id);
 }

package/test/store.test.mjs

@@ -506,6 +506,21 @@ test('到硬上限时归档最久没读的一条，不拒绝新记忆', () => {
   assert.equal(archived.current.body.length, chunk);
 });
 
+test('过期回执在任意写入时清掉，不靠接受候选', () => {
+  const scope = fresh('receipt-ttl');
+  const now = Date.now();
+  const stale = new Date(now - LIMITS.receiptTtlMs - 60 * 1000).toISOString();
+  const freshAt = new Date(now - 60 * 1000).toISOString();
+  state.transact(scope, { expectCreate: true }, (draft) => {
+    draft.receipts = [{ operationId: 'op_old', at: stale, changed: 1 }, { operationId: 'op_new', at: freshAt, changed: 2 }];
+    return { changed: true };
+  });
+  const saved = upsert(scope, { title: '顺手写一条', summary: '触发一次事务', body: '正文' });
+  assert.ok(saved.record.id);
+  const kept = stateOf(scope).receipts.map((row) => row.operationId);
+  assert.deepEqual(kept, ['op_new']);
+});
+
 test('the global layer reports both lines', () => {
   const global = globalScope();
   assert.equal(LIMITS.globalEntries, 200);