dsh-experience 1.1.1 → 1.2.1

package/CHANGELOG.md

@@ -1,6 +1,38 @@
 # Changelog
 
 
+## [1.2.1] — 2026-11-09 — 审计修复：召回语料、id 回收、模拟淘汰、恢复、G8 守卫
+
+### 修复
+- **召回漏传 IDF 语料**：`index.js` 召回处只传两个参数，`scoreExperience` 的第三参为空，所有词权重 1，常见词与稀有词同权——无关记录可能越过阈值被注入。现在与合并路径一致。
+- **`nextId` 不与现有 id 对账**：载入时与 `experiences`/`archive` 的最大 `exp-N` 对齐，不再复用已存在的 id（否则 `forget`/`archive` 会打到旧记录）。
+- **`decay --age N --apply` 用模拟未来时间真归档**：现在直接拒绝，`--age` 只用于展示。
+- **`restore` 是空操作**：恢复时把 `lastUsedAt` 置为当前时刻，记录不会立刻重新判为 dormant。
+- **淘汰会毁掉 G8 守卫**：`superseded` 不再进入淘汰候选（归档后同一指纹会被重新收录）。
+- **“没什么可抓”被记成失败**：只有真的出现失败调用、且指纹与记录一致时，G3 拒绝才写 failure，普通对话不再毒化证据链。
+- **临时文件名跨进程冲突**：`store.json.<pid>.tmp`，两个 DSH 进程同时写不再互相覆盖。
+- **`pitfalls` 别名**：删除 `if (existing.pitfalls)`（`[]` 为真）导致 pitfalls 指向 reverse_examples 的写法。
+
+### 测试
+- 新增 T87–T91、T63、T64；`node tools/selftest.mjs` 101 pass / 0 fail，`node tools/e2e.mjs` 25 pass / 0 fail。
+
+### 仍未做
+- 工具在写盘失败时仍回“成功”（`persist` 吞异常）；语料每轮仍重建 3 次；历史记录未回填 `pitfalls` 别名。
+
+## [1.2.0] — 2026-11-09 — 计划任务召回与已知问题清单
+
+### 修复
+- **计划任务的轮次召回为空**：这类会话的第一条消息是 `[SCHEDULE REMINDER] … reminder_prompt_json: "…"`，
+  整段被当成查询词，搜到的是 "schedule"。新增 `stripReminder()`，从包装里取出真实 prompt 再分词；
+  原文保留在 `trace.queryRaw`。测试 T84。
+
+### 新增
+- `docs/KNOWN-ISSUES.md`：八条已知问题，按"会不会让经验变错"排序，每条写症状/影响/现状/绕法
+  （含 shell 落盘不算写、`set_bundle` 不重载、召回只在第 1 步、纯词面检索、单机单用户等）。
+
+### 测试
+- `selftest 94 pass / 0 fail`、`e2e 23 pass / 0 fail`。
+
 ## [1.1.1] — 2026-11-09 — 构建标识修正
 
 - `BUILD` 从 `r20-scope-tools` 改为 `r21-platform`。1.1.0 的代码已含平台隔离，但包内构建标识还是上一个版本号，

package/README.md

@@ -150,6 +150,8 @@ plugin_manager install_bundle target=link:<PATH-TO-dsh-experience>
 - 淘汰只归档不删除，需要 `restore` 才能回到召回池；
 - 经验只描述「怎么做」，不包含业务代码本身。
 
+已知问题的完整清单（含症状、影响、绕法）见 [docs/KNOWN-ISSUES.md](docs/KNOWN-ISSUES.md)。
+
 ## 开发
 
 ```bash

package/index.js

@@ -35,7 +35,7 @@ const PROBE_FILE = path.join(STORE_DIR, 'probe.json')
 const THRESHOLD = 0.15
 const MAX_EXPERIENCES = 2
 const MAX_CHARS = 1600
-const BUILD = 'r21-platform'
+const BUILD = 'r23-audit-fixes'
 
 let CONFIG = { ...C.DEFAULT_CONFIG }
 
@@ -286,11 +286,12 @@ export function apply(ctx) {
     const step = payload.step
     if (!id || step !== 1) return
 
-    const queryText = (payload.messages || []).map(textOfMessage).join('\n')
+    const rawQuery = (payload.messages || []).map(textOfMessage).join('\n')
+    const queryText = R.stripReminder(rawQuery)
     const queryTokens = tokens(queryText)
     const index = R.corpus(store.experiences)
     const scored = store.experiences
-      .map((experience) => ({ experience, score: scoreExperience(experience, queryTokens) }))
+      .map((experience) => ({ experience, score: scoreExperience(experience, queryTokens, index) }))
       .sort((a, b) => b.score - a.score)
     const candidates = scored.slice(0, 5).map(({ experience, score }) => ({
       id: experience.id,
@@ -310,6 +311,7 @@ export function apply(ctx) {
       endedAt: null,
       steps: 0,
       query: queryText.slice(0, 400),
+      queryRaw: rawQuery === queryText ? undefined : rawQuery.slice(0, 400),
       queryTokens: [...queryTokens].slice(0, 40),
       candidates,
       threshold: threshold(),
@@ -520,15 +522,23 @@ export function apply(ctx) {
 
   function noteGatedFailure(trace) {
     try {
+      const calls = trace.calls || []
+      // Being refused for "nothing to capture" is not a failure of any recipe.
+      // A turn only voids a record's evidence chain when it actually hit an error
+      // while attempting that same job.
+      if (!calls.some((call) => call && call.ok === false)) return
+      const fingerprint = C.outcomeFingerprint(calls)
       const queryTokens = tokens(trace.query || '')
       const index = R.corpus(store.experiences)
       let best = null
       for (const existing of store.experiences) {
         if (!['verified', 'auto-verified', 'candidate'].includes(existing.status)) continue
         const score = scoreExperience(existing, queryTokens, index)
-        if (score >= CONFIG.mergeThreshold && (!best || score > best.score)) best = { existing, score }
+        if (score < CONFIG.mergeThreshold) continue
+        if (!C.fingerprintsMatch(existing, { fingerprint })) continue
+        if (!best || score > best.score) best = { existing, score }
       }
-      if (best) noteEvidence(best.existing, trace, 'failure', false, C.summarizeCalls(trace.calls || []))
+      if (best) noteEvidence(best.existing, trace, 'failure', false, C.summarizeCalls(calls))
     } catch (error) {
       console.warn('[experience] failure evidence failed:', error && error.message)
     }
@@ -1101,7 +1111,10 @@ export function apply(ctx) {
           const ageIndex = parts.indexOf('--age')
           const simulatedDays = ageIndex >= 0 ? Number(parts[ageIndex + 1]) : 0
           const simulated = Number.isFinite(simulatedDays) && simulatedDays > 0
-          const now = simulated ? Date.now() + simulatedDays * 86400000 : Date.now()
+          if (simulated && parts.includes('--apply')) {
+            return err('--age 只用于模拟展示，不能和 --apply 一起用：先用 --age 看水位，再不带 --age 执行 --apply')
+          }
+          const now = Date.now()
           if (!parts.includes('--apply')) {
             D.markDecay(store.experiences, Date.now(), CONFIG)
             persist()

package/lib/capture.js

@@ -723,7 +723,6 @@ export function mergeInto(existing, draft) {
     }
   }
   existing.reverse_examples = [...canonical, ...added].slice(0, 10)
-  if (existing.pitfalls) existing.pitfalls = existing.reverse_examples
 
   const stepSeen = new Set(existing.steps || [])
   const newSteps = []

package/lib/decay.js

@@ -127,7 +127,16 @@ export function selectEvictions(records, now = Date.now(), config = {}) {
     return { ...base, triggered: false, evictions: [], reason: `未达容量阈值 ${threshold}（当前 ${list.length}）` }
   }
   const eligible = list
-    .filter((record) => record && record.status !== 'verified' && record.status !== 'rejected' && !isPinned(record))
+    .filter(
+      (record) =>
+        record &&
+        record.status !== 'verified' &&
+        record.status !== 'rejected' &&
+        // Superseded records are the anti-re-adoption guard: archiving one lets the
+        // refused fingerprint be captured and recommended again.
+        record.status !== 'superseded' &&
+        !isPinned(record),
+    )
     .map((record) => ({ record, info: stateOf(record, now, config) }))
     .filter((entry) => entry.info.dormant)
     .sort((left, right) => left.info.rank - right.info.rank)
@@ -211,6 +220,9 @@ export function renderDecayReport(store, now = Date.now(), config = {}) {
   return lines.join('\n')
 }
 
+export const ARCHIVE_LIMIT = 200
+export const EVICTION_LIMIT = 500
+
 export function applyEvictions(store, now = Date.now(), config = {}, by = 'command') {
   const records = Array.isArray(store && store.experiences) ? store.experiences : []
   const proposal = selectEvictions(records, now, config)
@@ -240,6 +252,10 @@ export function applyEvictions(store, now = Date.now(), config = {}, by = 'comma
       ageDays: proposalItem ? proposalItem.ageDays : null,
     })
   }
+  // Archived records keep their whole body, so the list has to be bounded or the
+  // store grows forever on a long-lived machine.
+  if (store.archive.length > ARCHIVE_LIMIT) store.archive = store.archive.slice(-ARCHIVE_LIMIT)
+  if (store.evictions.length > EVICTION_LIMIT) store.evictions = store.evictions.slice(-EVICTION_LIMIT)
   return { archived: archived.map((record) => record.id), triggered: true, at, reason: `已归档 ${archived.length} 条（未物理删除，可用 /memory restore <id> 恢复）` }
 }
 
@@ -251,6 +267,9 @@ export function restoreRecord(store, id) {
   delete record.archivedAt
   delete record.archivedBy
   delete record.decay
+  // Resetting the snapshot alone would decay again on the next pass: age is
+  // measured from the last use, so a restore has to count as a use.
+  record.lastUsedAt = new Date(Date.now()).toISOString()
   store.experiences.push(record)
   store.evictions = Array.isArray(store.evictions) ? store.evictions : []
   store.evictions.push({ id, at: new Date().toISOString(), by: 'restore', reason: '人工恢复' })

package/lib/recall.js

@@ -87,6 +87,29 @@ export function expand(text) {
   return out
 }
 
+/**
+ * A scheduled turn starts with its delivery wrapper ("[SCHEDULE REMINDER] ...
+ * reminder_prompt_json: \"...\""). Searching that text finds the word
+ * "schedule" and nothing else, so recall reads the wrapped prompt instead.
+ */
+export function stripReminder(text) {
+  const raw = String(text || '')
+  if (!raw.includes('[SCHEDULE REMINDER]')) return raw
+  const spoiled = /reminder_prompt_json:\s*("(?:[^"\\]|\\.)*")/s.exec(raw)
+  if (spoiled) {
+    try {
+      const prompt = JSON.parse(spoiled[1])
+      if (prompt) return String(prompt)
+    } catch {
+      /* keep the raw text when the JSON is not what we expect */
+    }
+  }
+  return raw
+    .split('\n')
+    .filter((line) => !/^\s*\[SCHEDULE REMINDER\]/.test(line) && !/^\s*(schedule_id_json|occurrence_at|reminder_prompt_json)\s*:/.test(line))
+    .join('\n')
+}
+
 /** The searchable profile of a stored experience. */
 export function profileText(experience) {
   if (!experience) return ''

package/lib/store.js

@@ -1,15 +1,47 @@
-// Durable store I/O, split out of index.js so the reload path is testable.
-//
-// The bug this exists to prevent: `loadStore()` used to rebuild only
-// {version,nextId,nextInjectionId,experiences,injections,turns}, so every
-// reload dropped `archive` and `evictions` — and the next persist() rewrote
-// them out of the file, silently losing archived records.
+// A turn persists the store several times (injection bookkeeping, capture, decay,
+// trace close). Each write serialises the whole file, and by now the file carries
+// a hundred turns, so identical rewrites are pure waste. Two cheap guards:
+//   1. skip the write when the serialised payload equals the last one written;
+//   2. keep a counter so the tests can prove it, instead of trusting mtime.
 
 import fs from 'node:fs'
 
+const lastWritten = new Map()
+const stats = { writes: 0, skipped: 0 }
+
+export function writeStore(file, store) {
+  const text = JSON.stringify(store, null, 2)
+  // Same bytes as the last successful write to this path means nothing changed;
+  // several listeners can persist the same snapshot within one turn.
+  if (lastWritten.get(file) === text) {
+    stats.skipped += 1
+    return { written: false }
+  }
+  const dir = file.slice(0, Math.max(file.lastIndexOf('/'), file.lastIndexOf('\\')))
+  if (dir) fs.mkdirSync(dir, { recursive: true })
+  const tmp = `${file}.${process.pid}.tmp`
+  fs.writeFileSync(tmp, text, 'utf8')
+  fs.renameSync(tmp, file)
+  lastWritten.set(file, text)
+  stats.writes += 1
+  return { written: true }
+}
+
+/** Exposed for tests; also handy when diagnosing write amplification. */
+export function writeStats() {
+  return { ...stats }
+}
+
+/** Tests need a clean slate between fixtures. */
+export function resetWriteCache() {
+  lastWritten.clear()
+  stats.writes = 0
+  stats.skipped = 0
+}
+
 export function emptyStore() {
   return {
-    version: 1,
+    version: 2,
     nextId: 1,
     nextInjectionId: 1,
     experiences: [],
@@ -27,11 +59,18 @@ const array = (value) => (Array.isArray(value) ? value : [])
  * Unknown extra fields are preserved verbatim on purpose: a plugin upgrade that
  * adds a table must not lose it when an older build reloads the file.
  */
+const highestId = (list) =>
+  list.reduce((max, record) => {
+    const match = record && typeof record.id === 'string' ? /^exp-(\d+)$/.exec(record.id) : null;
+    return match ? Math.max(max, Number(match[1])) : max;
+  }, 0);
+
 export function normalizeStore(parsed) {
   if (!parsed || typeof parsed !== 'object') throw new Error('not an object')
   const known = {
     version: Math.max(2, Number(parsed.version || 1)),
-    nextId: Number(parsed.nextId) || 1,
+    // A hand-edited or truncated store must never hand out an id that already exists.
+    nextId: Math.max(Number(parsed.nextId) || 1, highestId([...array(parsed.experiences), ...array(parsed.archive)]) + 1),
     nextInjectionId: Number(parsed.nextInjectionId) || 1,
     experiences: array(parsed.experiences),
     injections: array(parsed.injections),
@@ -49,18 +88,12 @@ export function normalizeStore(parsed) {
 export function readStore(file) {
   try {
     const raw = fs.readFileSync(file, 'utf8')
-    return { store: normalizeStore(JSON.parse(raw)) }
+    const store = normalizeStore(JSON.parse(raw))
+    // Seed the cache so a read followed by an unchanged write is skipped too.
+    lastWritten.set(file, JSON.stringify(store, null, 2))
+    return { store }
   } catch (error) {
     if (error && error.code === 'ENOENT') return { store: emptyStore(), missing: true }
     return { store: emptyStore(), error }
   }
-}
-
-/** Atomic-ish write: temp file + rename, UTF-8, no BOM. */
-export function writeStore(file, store) {
-  const dir = file.slice(0, Math.max(file.lastIndexOf('/'), file.lastIndexOf('\\')))
-  if (dir) fs.mkdirSync(dir, { recursive: true })
-  const tmp = `${file}.tmp`
-  fs.writeFileSync(tmp, JSON.stringify(store, null, 2), 'utf8')
-  fs.renameSync(tmp, file)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-experience",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "private": false,
   "publishConfig": {
     "access": "public"

package/tools/e2e.mjs

@@ -410,6 +410,23 @@ await test('T62 the same recipe in a second project stays separate', async () =>
   assert.match(String(second.reason), /scope 不同|意图不同|按新任务/, `reason: ${second.reason}`)
 })
 
+await test('T63 --age is a simulation and refuses to combine with --apply', async () => {
+  const out = await cmd('decay --age 400 --apply');
+  assert.equal(out.kind, 'error', out.text);
+  assert.match(out.text, /不能和 --apply 一起用/);
+});
+
+await test('T64 a refused turn without errors does not void evidence', async () => {
+  const before = JSON.stringify(readStore().experiences.map((e) => e.proof || null));
+  await enter(A, 40, 1, '在 acme-app 里新增 pad 函数并配 node:test 用例');
+  await call(A, 'read', { file_path: 'D:\\work\\acme-app\\src\\pad.js' });
+  await call(A, 'read', { file_path: 'D:\\work\\acme-app\\test\\pad.test.mjs' });
+  await fire('agent/turn-stopping', { agent: A, turn: 40, signal: undefined });
+  const capture = readStore().turns.at(-1).capture;
+  assert.equal(capture.ok, false, JSON.stringify(capture));
+  assert.equal(JSON.stringify(readStore().experiences.map((e) => e.proof || null)), before, 'no failure evidence');
+});
+
 console.log('');
 let pass = 0;
 results.forEach((item, index) => {

package/tools/selftest.mjs

@@ -1198,6 +1198,95 @@ test('T83 a recipe from another OS is never merged and never recalled', () => {
   assert.equal(C.platformConflicts({}), false)
 })
 
+test('T84 a scheduled wrapper yields the task, not the wrapper', () => {
+  const wrapped = '[SCHEDULE REMINDER]\nThis is a scheduled message from the user\nschedule_id_json: "schedule-1"\noccurrence_at: 2026-11-09T02:57:00.000Z\nreminder_prompt_json: "在 D:\\\\work\\\\platgate 下创建 platgate.js 并运行"'
+  const task = R.stripReminder(wrapped)
+  assert.equal(task, '在 D:\\work\\platgate 下创建 platgate.js 并运行')
+  const tokens = R.expand(task)
+  assert.ok(tokens.has('platgate'))
+  assert.ok(!tokens.has('schedule'))
+  assert.equal(R.stripReminder('普通任务'), '普通任务')
+})
+
+test('T85 an unchanged store is not rewritten', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-store-'))
+  const file = path.join(dir, 'store.json')
+  S.resetWriteCache()
+  const store = S.emptyStore()
+  assert.equal(S.writeStore(file, store).written, true)
+  assert.equal(S.writeStore(file, store).written, false)
+  store.nextId = 7
+  assert.equal(S.writeStore(file, store).written, true)
+  const stats = S.writeStats()
+  assert.equal(stats.writes, 2)
+  assert.equal(stats.skipped, 1)
+  // A read seeds the cache, so "load then persist an untouched snapshot" is free.
+  S.resetWriteCache()
+  const reread = S.readStore(file)
+  assert.equal(S.writeStore(file, reread.store).written, false)
+  fs.rmSync(dir, { recursive: true, force: true })
+})
+
+test('T86 the archive keeps the newest 200 records', () => {
+  assert.equal(D.ARCHIVE_LIMIT, 200)
+  const store = { experiences: [], archive: [], evictions: [], nextId: 1 }
+  for (let i = 0; i < 205; i += 1) {
+    store.experiences.push({ id: 'exp-' + i, status: 'candidate', createdAt: '2020-01-01T00:00:00.000Z', steps: ['a', 'b'] })
+  }
+  const result = D.applyEvictions(store, Date.now(), { ...C.DEFAULT_CONFIG, libraryLimit: 10 }, 'test')
+  assert.ok(result.archived.length > 0)
+  assert.ok(store.archive.length <= D.ARCHIVE_LIMIT)
+  assert.equal(store.archive.at(-1).archivedBy, 'test')
+  assert.ok(store.evictions.length <= D.EVICTION_LIMIT)
+})
+
+test('T87 recall scores with the IDF corpus', () => {
+  const source = fs.readFileSync(new URL('../index.js', import.meta.url), 'utf8')
+  assert.ok(source.includes('scoreExperience(experience, queryTokens, index)'), 'recall passes the corpus')
+  assert.ok(!source.includes('scoreExperience(experience, queryTokens)'), 'no call site drops the corpus')
+})
+
+test('T88 a stale nextId is reconciled with existing ids', () => {
+  const store = S.normalizeStore({
+    nextId: 3,
+    experiences: [{ id: 'exp-1' }, { id: 'exp-9' }],
+    archive: [{ id: 'exp-12' }],
+  })
+  assert.equal(store.nextId, 13)
+  const empty = S.normalizeStore({ experiences: [] })
+  assert.equal(empty.nextId, 1)
+})
+
+test('T89 superseded records are never evicted', () => {
+  const now = Date.parse('2026-11-09T00:00:00Z')
+  const old = new Date(now - 400 * 86400000).toISOString()
+  const records = []
+  for (let i = 0; i < 159; i += 1) {
+    records.push({ id: 'exp-' + (100 + i), status: 'candidate', createdAt: old })
+  }
+  records.push({ id: 'exp-super', status: 'superseded', createdAt: old })
+  const result = D.selectEvictions(records, now, {})
+  assert.equal(result.triggered, true)
+  assert.ok(result.evictions.length > 0, 'old candidates are proposed')
+  assert.ok(!result.evictions.some((item) => item.id === 'exp-super'), 'the G8 guard stays in the library')
+})
+
+test('T90 restore makes a record young again', () => {
+  const now = Date.parse('2026-11-09T00:00:00Z')
+  const old = new Date(now - 400 * 86400000).toISOString()
+  const store = { experiences: [], archive: [{ id: 'exp-old', status: 'candidate', createdAt: old, steps: [] }], evictions: [] }
+  const restored = D.restoreRecord(store, 'exp-old')
+  assert.ok(restored, 'record comes back')
+  D.markDecay(store.experiences, now, {})
+  const decay = store.experiences[0].decay
+  assert.equal(decay.state, 'active')
+  assert.equal(decay.ageDays, 0)
+})
+
+test('T91 a fresh store starts at schema version 2', () => {
+  assert.equal(S.emptyStore().version, 2)
+})
+
 // ---------------------------------------------------------------- summary
 
 const total = pass + failures.length