dsh-experience 1.2.0 → 1.2.2

package/CHANGELOG.md

@@ -1,6 +1,47 @@
 # Changelog
 
 
+## [1.2.2] — 2026-11-09 — 体验修复：采集可靠性、候选可读性、旧经验降权
+
+**采集**
+- `tools/result` 与 turn 生命周期统一用 session id 对齐（原先工具侧取 `agent.id`、轮末取 `session.id`，不一致时整轮调用被记到另一个 key，表现为 `G1: 成功工具调用 < 2` 而实际跑了很多工具）。
+- 单 key 兜底搬运 + `trace.resultsSeen` / `trace.keyFallback`；G1 拒绝但确实收到过结果时写入 `capture.diagnostic`，不再静默。
+
+**召回**
+- 无 platform 标签的历史记录排序 ×0.85，注入块里标注「平台：未标注」。
+- `score()` 收到非字符串直接抛 `TypeError`（此前把记录对象传进去会静默得 0，看起来像"不相关"）。
+
+**候选可读性**
+- 标题带项目名：`新增 truncate（acme-app）`、`跑 run（cross-a）`。
+- 触发条件写真实验证命令，不再三条候选共用一句模板。
+- `stepLabel` 去掉 `cd …;` 前缀；`cd` / `Start-Sleep` 计入噪声。
+- 新增 `/memory review discard`：一次性拒绝当前所有候选（可审计，非删除）。
+
+**衰减**
+- 容量未达阈值时不再输出"观察项"清单（小库时那 5 条就是全部，纯噪声）。
+
+**测试**：`selftest 106` + `e2e 25` = 131 全部通过。
+
+**已知限制**：采集可靠性改动只经过单测与结构验证；真实轮次的效果需要下一个长轮次的 `capture.diagnostic` 来确认。
+
+## [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 — 计划任务召回与已知问题清单
 
 ### 修复

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 = 'r22-reminder'
+const BUILD = 'r24-ux-fixes'
 
 let CONFIG = { ...C.DEFAULT_CONFIG }
 
@@ -111,8 +111,21 @@ function tokens(text) {
   return R.expand(text)
 }
 
+/**
+ * Sessions own tool calls; an agent object can lose its id between the tool
+ * lifecycle and the turn lifecycle. Keying on the session keeps both sides in
+ * agreement — the mismatch was silently dropping every call of a turn.
+ */
+function keyOf(agent) {
+  if (!agent) return ''
+  return (agent.session && agent.session.id) || agent.id || ''
+}
+
 function scoreExperience(experience, queryTokens, index) {
-  return R.score(R.profileText(experience), queryTokens, index)
+  const base = R.score(R.profileText(experience), queryTokens, index)
+  // A recipe learned on another machine, or never tagged at all, is weaker evidence.
+  const factor = C.platformFactor(experience)
+  return Math.round(base * factor * 1000) / 1000
 }
 
 // Retrieval floor. Configurable via "/memory config set recallThreshold 0.1"
@@ -239,6 +252,7 @@ export function apply(ctx) {
   const traces = new Map()
   const bound = new Map()
   const liveCalls = new Map()
+  const resultsSeen = new Map()
   const probe = { done: false }
   let currentTrace = null
 
@@ -259,6 +273,8 @@ export function apply(ctx) {
       lines.push('')
       lines.push(`## ${experience.id} · ${experience.title}`)
       if (experience.when) lines.push(`适用：${experience.when}`)
+      // Untagged records predate platform isolation; say so rather than pretend.
+      if (!C.platformOf(experience)) lines.push('平台：未标注（旧经验，按通用配方参考）')
       const steps = (experience.steps || []).slice(0, 6)
       steps.forEach((step, index) => lines.push(`${index + 1}. ${step}`))
       const pitfalls = experience.pitfalls || experience.reverse_examples || []
@@ -291,7 +307,7 @@ export function apply(ctx) {
     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,
@@ -475,8 +491,9 @@ export function apply(ctx) {
   function recordCall(exec, result) {
     try {
       ensureProbe(exec, result)
-      const id = agentId(exec && exec.agent) || initiatorId()
+      const id = keyOf(exec && exec.agent) || initiatorId()
       if (!id) return
+      resultsSeen.set(id, (resultsSeen.get(id) || 0) + 1)
       const ok = pickOk(exec, result)
       const list = liveCalls.get(id) || []
       if (list.length >= 80) list.shift()
@@ -522,15 +539,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)
     }
@@ -724,15 +749,31 @@ export function apply(ctx) {
 
   ctx.on('agent/turn-stopping', (payload) => {
     try {
-      const id = agentId(payload && payload.agent)
-      const calls = liveCalls.get(id) || []
+      const id = keyOf(payload && payload.agent)
+      let calls = liveCalls.get(id) || []
       liveCalls.delete(id)
+      let keyFallback = false
+      if (!calls.length && liveCalls.size === 1) {
+        const [otherId, otherCalls] = liveCalls.entries().next().value
+        if (otherCalls && otherCalls.length) {
+          calls = otherCalls
+          liveCalls.delete(otherId)
+          keyFallback = true
+        }
+      }
+      const seen = resultsSeen.get(id) || 0
+      resultsSeen.delete(id)
       const trace = traces.get(id)
       if (!trace || trace.turn !== payload.turn) return
       trace.calls = calls.slice(-CONFIG.maxCalls)
+      trace.resultsSeen = seen
+      if (keyFallback) trace.keyFallback = true
       trace.endedAt = new Date().toISOString()
       trace.durationMs = Date.parse(trace.endedAt) - Date.parse(trace.startedAt)
       const capture = runCapture(trace, payload.agent)
+      if (capture && !capture.ok && /^G1/.test(String(capture.reason)) && seen > trace.calls.length) {
+        capture.diagnostic = `采集异常：本轮收到 ${seen} 次工具结果，只记录 ${trace.calls.length} 条${keyFallback ? '（已用 keyFallback 兜底）' : ''}`
+      }
       // Raw hints are needed while capturing (scope + fingerprint); they must not
       // reach the durable trace, so collapse them to the redacted form now.
       trace.calls = (trace.calls || []).map((call) => ({ ...call, hint: C.clip(call.hint, 120) }))
@@ -974,6 +1015,17 @@ export function apply(ctx) {
         }),
       ].join('\n')
     }
+    if (line === 'discard' || line === '--discard' || line === 'reject-all') {
+      const candidates = C.reviewTargets(store.experiences)
+      if (!candidates.length) return '没有待确认的候选经验。'
+      const at = new Date().toISOString()
+      for (const item of candidates) {
+        item.status = 'rejected'
+        item.verify = { by: 'human', at, method: 'command-reject-all' }
+      }
+      persist()
+      return `已拒绝 ${candidates.length} 条候选：${candidates.map((item) => item.id).join(', ')}`
+    }
     if (line === '--approve-all' || line === 'approve-all' || line === 'approve --all') {
       const candidates = C.reviewTargets(store.experiences)
       if (!candidates.length) return '没有待确认的候选经验。'
@@ -1103,7 +1155,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

@@ -120,6 +120,18 @@ export function classify(call) {
   return { kind, target, name }
 }
 
+/**
+ * "cd somewhere; node test.js" says nothing about the recipe beyond the command
+ * that actually ran, so keep only the trailing command.
+ */
+export function stripCdPrefix(command) {
+  const text = String(command || '').trim()
+  const parts = text.split(/\s*(?:;|&&|\|\|)\s*/).filter(Boolean)
+  if (parts.length <= 1) return text.replace(/;+$/, '')
+  const kept = parts.filter((part) => !/^cd\s/i.test(part) && !/^Set-Location\b/i.test(part))
+  return (kept.length ? kept.join('; ') : parts[parts.length - 1]).replace(/;+$/, '')
+}
+
 export function stepLabel(call) {
   const { kind, target, name } = classify(call)
   switch (kind) {
@@ -128,7 +140,7 @@ export function stepLabel(call) {
     case 'read':
       return target ? `读 ${target.split('/').pop()}` : '读文件'
     case 'run':
-      return target ? `跑 ${target}` : '执行命令'
+      return target ? `跑 ${stripCdPrefix(target)}` : '执行命令'
     case 'search':
       return target ? `检索 ${target}` : '检索'
     default:
@@ -172,7 +184,7 @@ export function stepPriority(call) {
  * output) is transcript noise: it describes how the agent measured the world,
  * not what a second run should do.
  */
-const NOISE_PREFIX = /^(\$|New-Item|New-ItemProperty|New-Object|Test-Path|Get-ChildItem|Get-Item|Set-Location|Push-Location|Pop-Location|Write-Host|Write-Output|Copy-Item|Remove-Item|Move-Item|Rename-Item)\b/
+const NOISE_PREFIX = /^(\$|New-Item|New-ItemProperty|New-Object|Test-Path|Get-ChildItem|Get-Item|Set-Location|Push-Location|Pop-Location|Write-Host|Write-Output|Write-Verbose|Clear-Host|Copy-Item|Remove-Item|Move-Item|Rename-Item|Start-Sleep|sleep|cd)\b/
 const ASSIGNMENT = /^[A-Za-z_$][\w$]*\s*=[^=]/
 
 export function isNoiseStep(label) {
@@ -541,6 +553,10 @@ const GENERIC_DIRS = new Set([
   // say nothing about *which project* a record belongs to.
   'node', 'python', 'python3', 'npm', 'pnpm', 'npx', 'yarn', 'git', 'pwsh',
   'deno', 'bun', 'runtime', 'runtimes', 'dependencies', 'dsh', 'windows',
+  // Home-directory placeholders: a user name is not a project name.
+  'dev', 'developer', 'user', 'userprofile',
+  // Sandbox and CI roots: fixtures live here, they are not project names.
+  'work', 'projects', 'repos',
 ])
 
 /**
@@ -636,22 +652,46 @@ export function buildCandidate(trace, info, config) {
   const named = writes
     .map((call) => artifactName(call))
     .find((name) => /^[A-Za-z0-9_][A-Za-z0-9_.-]*$/.test(name) && /[A-Za-z0-9]{2,}/.test(name))
+  // Scope is computed before rendering so the title and the trigger can name the
+  // project. "新增 index" is unreadable in a review list; "新增 index（dsh-experience）"
+  // tells the human which project the recipe belongs to.
+  const scope = mentionedDirs(
+    [
+      ...(calls || []).map((call) => firstString(call && (call.hint || call.argsHint || call.args))),
+      trace && trace.query,
+    ].join(' '),
+  )
+  const project = projectScope({ scope })[0] || ''
+  const suffix = project ? `（${project}）` : ''
   const title = clip(
     runOnly
       ? scriptName
-        ? `跑 ${scriptName}`
+        ? `跑 ${scriptName}${suffix}`
         : primary
           ? `跑 ${primary}`
           : verbsOf(taskType)
       : named
-        ? `新增 ${named}`
+        ? `新增 ${named}${suffix}`
         : primary
           ? `${verb} ${primary}`
           : verbsOf(taskType),
     110,
   )
   const place = workspaceName(info && info.cwd)
-  const when = clip(place ? `在 ${place} 里 ${verbsOf(taskType)}` : `当需要${verbsOf(taskType)}时`, 160)
+  const testRun = runs.find((call) => TEST_COMMAND.test(firstString(call && (call.hint || call.argsHint || call.args))))
+  const testCommand = testRun ? classify(testRun).target : ''
+  // The trigger line must discriminate between recipes, not repeat the task type
+  // ("在 desktop 里 新增函数/模块并配用例" fits every single candidate).
+  const when = clip(
+    project
+      ? `在 ${project} 里 ${verbsOf(taskType)}${testCommand ? `，验证 ${testCommand}` : ''}`
+      : testCommand
+        ? `当需要${verbsOf(taskType)}时，验证 ${testCommand}`
+        : place
+          ? `在 ${place} 里 ${verbsOf(taskType)}`
+          : `当需要${verbsOf(taskType)}时`,
+    160,
+  )
   const keywords = [...new Set([taskType, ...steps.map((step) => step.split(' ')[1] || '').filter(Boolean)])]
     .filter(Boolean)
     .slice(0, 12)
@@ -660,13 +700,11 @@ export function buildCandidate(trace, info, config) {
   const record = {
     status: 'candidate',
     platform: process.platform,
+    // Task shape as recorded, not as re-guessed from prose later: a write task and
+    // a "run this script" task must never merge even when they share every noun.
+    intent: runOnly ? 'run' : 'write',
     // Scope detection needs the raw paths; every rendered field below is normalized.
-    scope: mentionedDirs(
-      [
-        ...(calls || []).map((call) => firstString(call && (call.hint || call.argsHint || call.args))),
-        trace && trace.query,
-      ].join(' '),
-    ),
+    scope,
     fingerprint: outcomeFingerprint(calls),
     title,
     taskType,
@@ -703,6 +741,16 @@ export function platformOf(record) {
  * darwin. Unknown platform never vetoes: records written before v1.1 carry no
  * tag, and every one of them was learned on this machine.
  */
+/**
+ * Old records carry no platform tag: they were learned before isolation existed.
+ * They stay usable, but must not outrank a record that was proven on this machine.
+ */
+export function platformFactor(record) {
+  const tag = platformOf(record)
+  if (!tag) return 0.85
+  return tag === process.platform ? 1 : 0
+}
+
 export function platformConflicts(record) {
   const tag = platformOf(record)
   return Boolean(tag && tag !== process.platform)
@@ -723,7 +771,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)
@@ -200,17 +209,22 @@ export function renderDecayReport(store, now = Date.now(), config = {}) {
     `[M3.3 衰减报告] 库 ${live.length} 条 · active ${counts.active} / dormant ${counts.dormant} / pinned ${counts.pinned}`,
     ...(hiddenRejected ? [`已排除 ${hiddenRejected} 条 rejected（审计留档，不参与排序与容量；\/memory list --all 查看）`] : []),
     `容量: ${proposal.count}/${proposal.libraryLimit}（阈值 ${proposal.threshold} · 比例 ${num(config.capacityRatio, DECAY_DEFAULTS.capacityRatio)}）· ${proposal.triggered ? '已达阈值' : '未达阈值'}`,
-    proposal.triggered
-      ? `建议归档 ${proposal.evictions.length} 条（最多 ${num(config.evictBatch, DECAY_DEFAULTS.evictBatch)} 条/次，按 rank 升序）:`
-      : '容量尚未告警: 以下为 rank 最低的 5 条观察项，无需处理。',
-    ...(top.length
-      ? top.map((entry, index) => `  ${index + 1}. ${decayLine(entry.record, now, config)}${eligible.has(entry.record.id) ? '  ← 可归档' : ''}`)
-      : ['  (库为空)']),
+    ...(proposal.triggered
+      ? [
+          `建议归档 ${proposal.evictions.length} 条（最多 ${num(config.evictBatch, DECAY_DEFAULTS.evictBatch)} 条/次，按 rank 升序）:`,
+          ...(top.length
+            ? top.map((entry, index) => `  ${index + 1}. ${decayLine(entry.record, now, config)}${eligible.has(entry.record.id) ? '  ← 可归档' : ''}`)
+            : ['  (库为空)']),
+        ]
+      : [`容量充足（${proposal.count}/${proposal.libraryLimit}），暂时不需要淘汰任何记录。`]),
     '只列出建议，不删除任何记录。确认后运行 /memory decay --apply（移入 archive，可用 /memory restore <id> 恢复）。',
   ]
   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 +254,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 +269,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

@@ -138,6 +138,11 @@ const round = (value) => Math.round(value * 1000) / 1000
  * Empty means "cannot tell" and never vetoes anything.
  */
 export function intentOf(experienceOrText) {
+  // Records written by buildCandidate carry the intent they were captured with.
+  // Re-deriving it from prose is only the fallback for hand-written records.
+  if (experienceOrText && typeof experienceOrText === 'object' && (experienceOrText.intent === 'run' || experienceOrText.intent === 'write')) {
+    return experienceOrText.intent
+  }
   const text =
     typeof experienceOrText === 'string' ? experienceOrText : profileText(experienceOrText)
   const found = features(text)
@@ -207,6 +212,11 @@ const scriptWeight = (token) => (/^[\u4e00-\u9fff]+$/.test(token) ? 0.45 : 1)
  * Both terms are bounded, so the result is always within [0, 1].
  */
 export function score(profile, queryTokens, c) {
+  // Passing a record here used to score 0 silently, which looks exactly like
+  // "this experience is irrelevant" from the outside. Fail loudly instead.
+  if (typeof profile !== 'string') {
+    throw new TypeError('score() expects plain text; call profileText(record) first')
+  }
   const expTokens = expand(profile)
   if (!queryTokens || !queryTokens.size || !expTokens.size) return 0
   let weightSum = 0

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.2.0",
+  "version": "1.2.2",
   "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

@@ -341,7 +341,7 @@ test('buildCandidate: shape, taskType, steps, evidence', () => {
   assert.equal(draft.source.auto, true)
   assert.equal(draft.verify, null)
   assert.equal(draft.occurrences, 1)
-  assert.equal(draft.title, '新增 truncate')
+  assert.equal(draft.title, '新增 truncate（acme-app）')
   assert.ok(draft.when.includes('acme-app'), draft.when)
   assert.deepEqual(draft.steps, ['写 src/<name>.js', '跑 node test/<name>.mjs'])
   assert.equal(draft.evidence, 'session-x:turn-3 · calls=3 errors=0')
@@ -710,7 +710,9 @@ test('T30: decayLine and decay report expose rank/age and stay proposal-only', (
   assert.ok(report.includes('只列出建议，不删除任何记录'), report)
   assert.ok(report.includes('/memory decay --apply'), report)
   assert.ok(report.includes('/memory restore <id>'), report)
-  assert.equal(report.split('\n').filter((row) => /^ {2}\d+\. /.test(row)).length, 2, 'pinned is excluded from the ranking')
+  // Under capacity there is nothing to rank: no observation list at all.
+  assert.ok(report.includes('容量充足'), report)
+  assert.equal(report.split('\n').filter((row) => /^ {2}\d+\. /.test(row)).length, 0, 'no observation list under capacity')
   const many = [...records, ...Array.from({ length: 160 }, (_, i) => ({ id: `f-${i}`, status: 'candidate', lastUsedAt: ago(1) }))]
   const hot = D.renderDecayReport({ experiences: many }, NOW)
   assert.ok(hot.includes('已达阈值'), hot)
@@ -814,7 +816,7 @@ test('T34: a real recipe still passes G7 and gets an actionable title', () => {
   const gate = C.gateStepQuality(trace, draft, C.DEFAULT_CONFIG)
   assert.equal(gate.ok, true, gate.reason)
   assert.equal(gate.effective, 2)
-  assert.equal(draft.title, '新增 truncate')
+  assert.equal(draft.title, '新增 truncate（acme-app）')
   assert.equal(C.actionableTitle(draft.title), true)
 })
 
@@ -1135,7 +1137,7 @@ test('T78 a pure run track is captured, titled and fingerprinted by its command'
   assert.equal(quality.ok, true, quality.reason)
 
   const draft = C.buildCandidate(trace, { runOnly: true }, C.DEFAULT_CONFIG)
-  assert.equal(draft.title, '跑 run')
+  assert.equal(draft.title, '跑 run（cross-a）')
   assert.deepEqual(draft.fingerprint.commands, ['node'])
   assert.deepEqual(C.commandHeads(calls), ['node'])
 })
@@ -1208,6 +1210,120 @@ test('T84 a scheduled wrapper yields the task, not the wrapper', () => {
   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)
+})
+
+// ---------------------------------------------------------------- v1.2.2
+
+test('score: a non-string profile fails loudly instead of scoring 0', () => {
+  assert.throws(() => R.score({ title: 'x' }, R.expand('新增函数'), R.corpus([])), /profileText/)
+  assert.equal(typeof R.score('新增 pad 函数', R.expand('新增 pad 函数'), R.corpus([])), 'number')
+})
+
+test('platformFactor: untagged records are discounted, foreign ones excluded', () => {
+  assert.equal(C.platformFactor({}), 0.85)
+  assert.equal(C.platformFactor({ platform: process.platform }), 1)
+  assert.equal(C.platformFactor({ platform: process.platform === 'win32' ? 'linux' : 'win32' }), 0)
+})
+
+test('stepLabel: hangs off the command, not the scaffolding in front of it', () => {
+  const label = C.stepLabel({ name: 'pwsh', hint: 'cd D:\\work\\acme-app; node test\\pad.test.mjs', ok: true })
+  assert.ok(!label.includes('cd '), label)
+  assert.ok(label.includes('node'), label)
+  assert.ok(C.isNoiseStep('cd D:\\work'), 'a bare cd is not a step')
+  assert.ok(C.isNoiseStep('Start-Sleep -Seconds 2'), 'waiting is not a step')
+})
+
+test('buildCandidate: when names the project and the verification command', () => {
+  const draft = C.buildCandidate(sampleTrace(), { cwd: 'D:\\work\\acme-app', sessionId: 'session-z' })
+  assert.ok(draft.when.includes('acme-app'), draft.when)
+  assert.ok(draft.when.includes('node'), draft.when)
+  assert.notEqual(draft.when, '在 desktop 里 新增函数/模块并配用例')
+})
+
+test('decay report stays quiet while the library is nowhere near capacity', () => {
+  const records = [{ id: 'exp-1', status: 'verified', title: 'x', uses: 1, at: new Date(NOW).toISOString() }]
+  const report = D.renderDecayReport({ experiences: records }, NOW, { libraryLimit: 200 })
+  assert.ok(report.includes('容量充足'), report)
+  assert.ok(!report.includes('观察项'), report)
+})
+
 // ---------------------------------------------------------------- summary
 
 const total = pass + failures.length