dsh-experience 1.0.5 → 1.0.14

package/CHANGELOG.md

@@ -1,5 +1,190 @@
 # Changelog
 
+
+## [1.0.14] — 2026-11-09 — A/B 效率实测记录
+
+### 记录
+- `docs/TESTING.md` 新增第 7 节：冷/热两轮对照（`recallThreshold` 1.0 vs 0.15）的完整表格、
+  两轮原始调用清单、`inj-52` 注入记录，以及六条偏差声明（n=1、顺序效应、编辑粒度、夹具复用、
+  同族不同题、环境一致）。
+- 实测：调用 18 → 9（−50%）、耗时 80.4s → 32.3s（−60%）、注入 524 token、重复踩坑 0 次。
+
+### 明确不宣称
+- 不把单轮对照当作"平均提升"。要支持平均值需要每格 ≥5 轮并随机化顺序。
+
+### 维护
+- 清理验收期夹具目录（cache-lab、cross-A/B、intent-test、exp-bench2/3/4 等），保留 `exp-bench`
+  作为 v0.1 闭环的历史证据。
+
+## [1.0.13] — 2026-11-09 — 跨项目合并回归：scope 被工具链 token 桥接
+
+### 修复
+- 三轮实跑验证发现：同配方换项目仍被「结果指纹」合并。根因是 `mentionedDirs()` 把
+  `…\node\bin\node.exe` 的最深段 `node` 也当作目录，而 `scopeConflicts()` 用集合交集判断同项目，
+  于是 `[cross-a, node]` 与 `[cross-b, node]` 因共享 `node` 被判为同一项目。
+- `GENERIC_DIRS` 增补工具链目录（node/python/npm/pnpm/git/pwsh/deno/runtime/dependencies/dsh…）。
+- 新增 `projectScope(record)`：比较前先滤掉通用目录；`scopeConflicts()` 改用它。
+- run 型记录标题改为始终「跑 <script>」（此前仅 `runOnly` 时为该格式，混合轨迹会退回「跑通 node <name>」）。
+
+### 测试
+- T80：`cross-a` 与 `cross-b` 共享 `node` 时仍判冲突；只知工具链的记录保持中立。
+- T81：run 型标题恒为「跑 run」。
+- e2e T62：同一配方在两个项目里必须各自建档，不得合并。
+- `selftest 91 pass / 0 fail`、`e2e 23 pass / 0 fail`。
+
+### 说明
+- v1.0.12 及更早版本中「跨目录已验证」的结论不成立，本次修正后需重跑一次轮 2 才算复验。
+- 文档：`docs/TESTING.md` 第 6 节、`ACCEPTANCE.md` 第 10 节记录了三轮原始日志与本次回归。
+
+## [1.0.12] — 2026-11-09 — 纯 run 轨迹可以被捕获了
+
+### 修复
+- 此前 `stepPriority` 只把「写」算 3 分、「测试执行」算 4 分，普通命令只有 2 分，
+  所以「写一个文件 + 跑一次」永远只有 1 个有效步骤，G7 直接拦截——`scope` 与 `intent` 两道闸门根本轮不到执行。
+- `shouldCapture(trace, counts, config, intent)`：`intent === "run"` 时，只要成功执行 ≥2 次（建目录/读文件不计）即可过 G3。
+- `gateStepQuality(..., intent)`：run 型轨迹改用 `runSteps()` 计量，理由串写明「可复用执行（建目录/读文件不计）」。
+- `buildCandidate()`：run 型记录标题改为「跑 `<script>`」，产物名取命令里真实的脚本名。
+- 指纹新增 `commands`（`commandHeads()`），记录实际启动的程序首词：`& "…\node.exe" x.mjs` → `node`。
+
+### 测试
+- T78：纯 run 轨迹（mkdir + 两次 node 执行）过 G3/G7，标题 `跑 run`，指纹 `commands: ["node"]`。
+- T79：只有 mkdir/Get-Content 的轨迹仍被 G3 拒；write 型轨迹仍要求两个有效步骤（回归）。
+- e2e T61：整轮只有两次 `pwsh` 执行时，capture 通过并落库。
+- `selftest 89 pass / 0 fail`、`e2e 22 pass / 0 fail`。
+
+### 说明
+- 这是「保守版」：只放宽 run 意图，write 意图的阈值一字未动；mkd/读文件仍被 `isNoiseStep` 挡在计量之外。
+- 夹具 `cross-A` / `cross-B` 已就绪（`src/math.js` + `test/math.test.mjs` + `run.mjs`），用于验证 scope 与 intent 拦截。
+
+## [1.0.11] — 2026-11-09 — rejected 记录退出计数与容量口径
+
+### 体验问题
+- 被 /memory reject 掉的记录仍被算进「库 N 条」和衰减报告，把数字撑得不像实话。
+
+### 修复
+- `/memory debug` 的库计数改为活动库条数，并单列 `rejected N`。
+- `/memory decay` 报告与 `selectEvictions()` 都跳过 `rejected`：它们不参与排序、不占容量、永不归档。
+  报告末尾显示「已排除 N 条 rejected（审计留档…）」。
+- `/memory list` 默认隐藏 rejected；`/memory list --all` 才显示，隐藏时给出提示行。
+
+### 测试
+- T77：库计数只算 2 条、报告出现「已排除 1 条」、rejected 不进排行、不会被 selectEvictions 选中。
+- e2e T60：reject 后 list 不显示、`list --all` 显示、debug 出现 `rejected 1`。
+- `selftest 87 pass / 0 fail`、`e2e 21 pass / 0 fail`。
+
+### 说明
+- rejected 仍保留在 store.json 里作为审计证据，也能被 `supersede`/`restore` 流程引用；只是不再参与任何统计与容量判断。
+
+## [1.0.10] — 2026-11-09 — 意图桶分离：run 与 write 不再互相吸收
+
+### 修复
+- 合并前先比意图类：`R.intentOf()` 把文本归为 run（跑 / 运行 / 执行）或 write（新增 / 实现 / 修改），
+  `R.intentConflict()` 只在两侧都有明确意图且不同时返回 true。
+- 两条合并路径（结果指纹、词面计分）都先过 `intentBlocked()`；被拦下时按新任务建档，
+  reason 追加「意图不同（run vs write），不并入 exp-N」。
+- 任一侧意图含糊（同时出现 run 与 write，或都没有）不否决——不确定时宁可合并，避免库碎裂。
+
+### 测试
+- T75：run 配方与 write 任务互相冲突，同类不冲突。
+- T76：含糊 / 空文本永不否决。
+- e2e T59：库里已有 run 型 verified 经验时，write 型任务照旧新建，且 reason 写明意图不同。
+- `selftest 86 pass / 0 fail`、`e2e 20 pass / 0 fail`。
+
+### 说明
+- 这条闸门针对「同一批名词、不同活」的误合并（例如「运行图片处理脚本」与「写一个图片处理脚本」）。
+  它不替代产物类型闸门：类型冲突先拦，意图冲突再拦。
+- exp-30 因两次误合并导致 occurrences 虚高，已归档（`store.archive` + `evictions` 审计，可 `/memory restore`）。
+
+## [1.0.9] — 2026-11-09 — 产物类型闸门（跨类型不合并）
+
+现象：一个「把图中 54+188 改成 91」的图片编辑任务，被合并进一条已有经验的轨迹里，
+occ 从 1 变 2。产出「全绿」加上词面相似度就足以命中合并，**没人在看产出是什么类型**。
+
+根因（两条路径都要挡）：
+
+1. 指纹匹配只看文件名与 green，.png 产物不入 targets，于是「双方都有绿 + 某个名字相同」即可合并；
+2. 词面合并（mergeThreshold）根本不关心产物类型——本次真实合并其实是这条路
+   （byFingerprint: false，score 0.761 / 0.891），不是指纹。
+
+修法：
+
+- 新增 artifactKindOf() / artifactKindsOf() / artifactTypesConflict()：按扩展名把产物分成
+  code / image / doc / binary 四类；两侧都有类型证据且**无交集**即判冲突。
+- outcomeFingerprint() 现在记录 kinds（仍保留 targets 的代码文件语义，兼容旧记录）。
+- fingerprintsMatch() 增加类型前置条件：同名不同类型不算同一结果。
+- runCapture() 对**词面合并**同样加类型闸门，冲突时不合并、按新任务建档，
+  并在 reason 里写明「产物类型不同（code vs image），不并入 exp-N（相似度 X）」。
+- 旧记录在 loadStore() 时由 targets 反推 kinds（幂等），让闸门对历史库同样生效。
+
+测试：T72（.png 结果不得与 .py 配方指纹合并）、T73（仅一侧有类型证据时不否决）、
+T74（outcomeFingerprint 正确记录 kinds 与 targets）。合计 selftest 84 pass、e2e 19 pass。
+
+## [1.0.8] — 2026-11-09 — CI 测试与持久化回归
+
+### 新增
+
+- `.github/workflows/test.yml`：每次 push 到 `main` 与每个 pull request 都跑
+  `node tools/selftest.mjs` 与 `node tools/e2e.mjs`，矩阵覆盖 Ubuntu/Windows × Node 20/22。
+  此前仓库只有「打 tag 时发布 npm」的流水线，代码从不经过测试。
+- `lib/store.js`：把 store 读写从 `index.js` 抽出来，成为可测试的纯模块
+  （`emptyStore / normalizeStore / readStore / writeStore`，写入走临时文件 + rename）。
+- `T69`：写入 → 重载 → 断言 `archive` / `evictions` / `nextId` 全部还在。
+- `T70`：未知字段（未来版本新增的表）在旧版本 reload 时不被丢弃。
+- `T71`：损坏 JSON 返回 `{error, store}` 而不是抛异常；缺失文件标记 `missing`。
+
+### 修复
+
+- `loadStore()` 不再自己重建字段，改走 `normalizeStore()`——这正是 1.0.7 里
+  `archive` / `evictions` 被静默抹掉的根因。
+- `e2e` T46 原先断言 `store.archive === undefined`，等于把上面那个 bug 写进了测试；
+  改为断言「归档条数为 0」。
+
+### 测试
+
+`selftest 81 pass / 0 fail`、`e2e 19 pass / 0 fail`（合计 100）。
+
+## [1.0.7] — 2026-11-09 — 检索：把「坑」纳入档案，修流水账挤掉垂直经验
+
+现象：真实任务（plugin-test-5 写 .mjs、require 不存在的模块、报错后排查修复）
+检索 PASS 且 top=0.26，但注入的是 exp-23/24（写文件流水账），exp-26（node.exe / MODULE_NOT_FOUND 避坑指南）
+连前五都没进。
+
+根因两条：
+
+1. **打分只看 title/when/keywords，不看 pitfalls/reverse_examples**。经验真正的价值在坑里
+   （`MODULE_NOT_FOUND`、`CommandNotFoundException`），这些词根本没进索引。
+2. **特征桶权重太平均**。`#error` 和 `#node` 与 `#file` 同权，一句「报错」压不过一堆「文件/新增」。
+
+修法：
+
+- `profileText()` 把 `pitfalls` 与 `reverse_examples` 一起入索引。
+- 特征桶分级权重：`#error` 3、`#node` 2.6、`#module` 2.2、`#shell`/`#debug` 2、`#run`/`#write` 1.8、其余 1.4/1.2。
+- 关键特征（`#error`/`#node`/`#module`）同时命中时再给 0.08/个 的确定性加分。
+- 新增工具 `experience_archive`：把记录移入 `store.archive`（可 `/memory restore` 恢复，写 `evictions` 审计），
+  用于清理已批准的流水账；不删除数据。
+
+实测（真实库，清理 exp-22..25 后剩下 4 条）：四条真实失败查询上 exp-26 全部排第 1
+（0.364 / 0.373 / 0.502 / 0.502），无关查询仍为 0。测试：selftest 78 pass、e2e 19 pass。
+
+## [1.0.6] — 2026-11-09 — 检索：停用词、特征桶与 idf 加权
+
+现象：一条噪声较大的任务描述（"跑一个会踩坑的 .mjs 脚本…内置 node.exe 模块报错"）
+在旧打分下只有 0.07，exp-26 根本没被召回。
+
+修法：
+
+- 停用词扩到口语填充词（随便/故意/场景/试试…），噪声不再稀释覆盖率。
+- 新增特征桶（`#node` `#shell` `#error` `#module` `#test` `#file` `#path` `#run` `#write` `#debug` …），
+  在原始文本上判定，词表不重合也能命中；`#run`/`#write` 区分"跑脚本"与"加函数"这两类意图。
+- 打分改为 idf 加权：跨经验常见的词（报错/模块/脚本）权重低，稀有词（node.exe/MODULE_NOT_FOUND）权重高；
+  中文 bigram 权重 ×0.45（它们最容易误撞）。
+- 索引文件名 basename，"truncate.test.mjs" 也能匹配 "test/truncate.test.mjs"。
+- 阈值可配：`/memory config set recallThreshold 0.1`（默认仍 0.15；实测无关查询得分为 0，
+  噪声查询下第二名 0.143，降到 0.05 会把第二名一起放进来）。
+
+实测（真实库 7 条）：噪声查询 exp-26=0.159 排第一；"新增纯函数+用例" exp-1=0.852；
+"重命名图片" 全部 0。测试 77 pass（selftest）/ 19 pass（e2e）。
+
 ## [1.0.5] — 2026-11-09 — 第一个 npm 版本
 
 - 发布到 npm：`dsh-experience@1.0.4` 是首个公开版本，`1.0.5` 修正安装说明。

package/README.md

@@ -2,7 +2,7 @@
 
 > **带生命周期治理与指纹防伪的 DSH 跨会话自学习插件** —— 同类任务第一次慢，第二次直接用上第一次的经验，但绝不把一次偶然的变通当成真理。
 
-[![tests](https://img.shields.io/badge/tests-62%20passing-brightgreen)](tools/selftest.mjs)
+[![tests](https://img.shields.io/badge/tests-114%20passing-brightgreen)](tools/selftest.mjs)
 [![license](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
 [![runtime](https://img.shields.io/badge/runtime-DeepSeek%20Harness-purple)](https://github.com/Aatzer0/dsh-experience)
 
@@ -97,7 +97,7 @@ plugin_manager install_bundle target=link:<PATH-TO-dsh-experience>
 | `/memory decay [--apply]` | 只读水位报告；`--apply` 归档（可用 `restore` 恢复） |
 | `/memory supersede <id> [原因]` | 标记与当前规则冲突：永不召回，同指纹的轨迹也不再收录 |
 
-完整命令见 [USER-GUIDE.md](USER-GUIDE.md)。
+完整命令见 [USER-GUIDE.md](USER-GUIDE.md)，完整教程见 [docs/USAGE.md](docs/USAGE.md)。
 
 ## 配置
 
@@ -122,18 +122,26 @@ plugin_manager install_bundle target=link:<PATH-TO-dsh-experience>
 - 注入前做长度截断（默认 2 条 / 1600 字符）；
 - 仓库不包含任何作者运行时数据，骨架见 [store.example.json](store.example.json)。
 
+## 检索加权
+
+当任务包含报错（`#error`）或明确排错意图时，含有避坑经验的历史条目将获得 3 倍以上的检索加权，确保模型优先复用排错捷径。
+
+实现上：`pitfalls` 与 `reverse_examples` 一并入索引，特征桶分级加权（`#error` 3、`#node` 2.6、`#module` 2.2…），
+`#error`/`#node`/`#module` 同时命中再加确定性加分。实测同一批失败查询上，正确条目的分数从 0.07 提升到 0.36–0.50，
+并在清理流水账后稳定排第 1。
+
 ## 已知限制
 
 - 召回仅在每轮第 1 步生效；
 - `auto-verified` 默认不参与召回 —— 错误经验的代价高于多一次点击；
-- 相似度是词覆盖打分，不做向量检索（零依赖的代价）；
+- 相似度是词覆盖打分 + 特征桶，不做向量检索（零依赖的代价）；**同义改写可能漏召回**——记录里写 `MODULE_NOT_FOUND`、提问只说「模块找不到」时不一定匹配，这需要向量检索才能解决，属能力边界；
 - 淘汰只归档不删除，需要 `restore` 才能回到召回池；
 - 经验只描述「怎么做」，不包含业务代码本身。
 
 ## 开发
 
 ```bash
-node tools/selftest.mjs   # 72 pass / 0 fail（纯函数 + 闸门 + 衰减）
+node tools/selftest.mjs   # 91 pass / 0 fail（纯函数 + 闸门 + 衰减）
 node tools/e2e.mjs        # 19 pass / 0 fail（假 Cordis context 驱动真实 apply()）
 ```
 

package/index.js

@@ -19,6 +19,8 @@ import crypto from 'node:crypto'
 import * as C from './lib/capture.js'
 import * as E from './lib/evidence.js'
 import * as D from './lib/decay.js'
+import * as R from './lib/recall.js'
+import * as S from './lib/store.js'
 import { renderLookup } from './lib/lookup.js'
 
 export const name = 'dsh-experience'
@@ -33,25 +35,10 @@ const PROBE_FILE = path.join(STORE_DIR, 'probe.json')
 const THRESHOLD = 0.15
 const MAX_EXPERIENCES = 2
 const MAX_CHARS = 1600
-const BUILD = 'r11-supersede'
+const BUILD = 'r20-scope-tools'
 
 let CONFIG = { ...C.DEFAULT_CONFIG }
 
-const STOP = new Set([
-  '的', '了', '和', '与', '在', '是', '把', '并', '就', '还', '也', '有', '用', '要', '中',
-  'the', 'a', 'an', 'and', 'or', 'to', 'of', 'in', 'on', 'for', 'with', 'is', 'are', 'be',
-  'it', 'this', 'that', 'then', 'use', 'run', 'can',
-])
-
-const emptyStore = () => ({
-  version: 1,
-  nextId: 1,
-  nextInjectionId: 1,
-  experiences: [],
-  injections: [],
-  turns: [],
-})
-
 function loadConfig() {
   try {
     const raw = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'))
@@ -83,77 +70,56 @@ function saveConfig() {
 }
 
 function loadStore() {
-  try {
-    const raw = fs.readFileSync(STORE_FILE, 'utf8')
-    const parsed = JSON.parse(raw)
-    if (!parsed || typeof parsed !== 'object') throw new Error('not an object')
-    const store = {
-      version: Math.max(2, Number(parsed.version || 1)),
-      nextId: parsed.nextId || 1,
-      nextInjectionId: parsed.nextInjectionId || 1,
-      experiences: Array.isArray(parsed.experiences) ? parsed.experiences : [],
-      injections: Array.isArray(parsed.injections) ? parsed.injections : [],
-      turns: Array.isArray(parsed.turns) ? parsed.turns : [],
-    }
-    E.migrateStore(store)
-    // Records written before the redaction fix may still carry absolute paths.
-    let scrubbed = 0
-    for (const record of store.experiences) if (C.scrubRecord(record)) scrubbed += 1
-    if (scrubbed) console.warn(`[experience] scrubbed ${scrubbed} legacy record(s)`)
-    return store
-  } catch (error) {
-    if (error && error.code === 'ENOENT') return emptyStore()
+  const result = S.readStore(STORE_FILE)
+  if (result.error) {
     try {
       fs.renameSync(STORE_FILE, `${STORE_FILE}.broken-${Date.now()}`)
     } catch {}
-    console.warn('[experience] store unreadable, started empty:', error && error.message)
-    return emptyStore()
+    console.warn('[experience] store unreadable, started empty:', result.error && result.error.message)
+  }
+  const store = result.store
+  E.migrateStore(store)
+  // Records written before the redaction fix may still carry absolute paths.
+  let scrubbed = 0
+  for (const record of store.experiences) if (C.scrubRecord(record)) scrubbed += 1
+  // Records written before 1.0.9 carry no artifact kinds; derive them so the
+  // cross-type veto also protects the existing library.
+  let kindsBackfilled = 0
+  for (const record of store.experiences) {
+    if (record.fingerprint && !Array.isArray(record.fingerprint.kinds)) {
+      record.fingerprint.kinds = C.artifactKindsOf(record.fingerprint.targets)
+      kindsBackfilled += 1
+    }
   }
+  // Write it back once: otherwise the guard only sees kinds after the next merge.
+  if (kindsBackfilled) {
+    try {
+      saveStore(store)
+    } catch (error) {
+      console.warn('[dsh-experience] could not persist fingerprint kinds:', error && error.message)
+    }
+  }
+  if (scrubbed) console.warn(`[experience] scrubbed ${scrubbed} legacy record(s)`)
+  return store
 }
 
 function saveStore(store) {
-  fs.mkdirSync(STORE_DIR, { recursive: true })
-  const tmp = `${STORE_FILE}.tmp`
-  fs.writeFileSync(tmp, JSON.stringify(store, null, 2), 'utf8')
-  fs.renameSync(tmp, STORE_FILE)
+  S.writeStore(STORE_FILE, store)
 }
 
 function tokens(text) {
-  const out = new Set()
-  const source = String(text || '').toLowerCase()
-  for (const match of source.matchAll(/[a-z0-9_][a-z0-9_.\-/]*/g)) {
-    const token = match[0]
-    if (token.length >= 2 && !STOP.has(token)) out.add(token)
-  }
-  const cjk = source.replace(/[^\u4e00-\u9fff]+/g, ' ')
-  for (const chunk of cjk.split(' ')) {
-    for (let i = 0; i + 1 < chunk.length; i++) {
-      const bigram = chunk.slice(i, i + 2)
-      if (!STOP.has(bigram)) out.add(bigram)
-    }
-  }
-  return out
+  return R.expand(text)
 }
 
-function profileTokens(experience) {
-  return tokens([
-    experience.title,
-    experience.taskType,
-    experience.when,
-    (experience.keywords || []).join(' '),
-  ].join(' '))
+function scoreExperience(experience, queryTokens, index) {
+  return R.score(R.profileText(experience), queryTokens, index)
 }
 
-function scoreExperience(experience, queryTokens) {
-  const expTokens = profileTokens(experience)
-  if (!queryTokens.size || !expTokens.size) return 0
-  let queryHits = 0
-  for (const token of queryTokens) if (expTokens.has(token)) queryHits++
-  let expHits = 0
-  for (const token of expTokens) if (queryTokens.has(token)) expHits++
-  const queryCoverage = queryHits / queryTokens.size
-  const expCoverage = expHits / expTokens.size
-  return Math.round((0.7 * queryCoverage + 0.3 * expCoverage) * 1000) / 1000
+// Retrieval floor. Configurable via "/memory config set recallThreshold 0.1"
+// because the right value depends on how noisy the task descriptions are.
+function threshold() {
+  const value = Number(CONFIG.recallThreshold)
+  return Number.isFinite(value) && value > 0 ? value : THRESHOLD
 }
 
 function textOfMessage(message) {
@@ -321,6 +287,7 @@ export function apply(ctx) {
 
     const queryText = (payload.messages || []).map(textOfMessage).join('\n')
     const queryTokens = tokens(queryText)
+    const index = R.corpus(store.experiences)
     const scored = store.experiences
       .map((experience) => ({ experience, score: scoreExperience(experience, queryTokens) }))
       .sort((a, b) => b.score - a.score)
@@ -329,10 +296,10 @@ export function apply(ctx) {
       title: experience.title,
       status: experience.status,
       score,
-      passed: recallable(experience) && score >= THRESHOLD,
+      passed: recallable(experience) && score >= threshold(),
     }))
     const chosen = scored
-      .filter((entry) => recallable(entry.experience) && entry.score >= THRESHOLD)
+      .filter((entry) => recallable(entry.experience) && entry.score >= threshold())
       .slice(0, MAX_EXPERIENCES)
 
     const trace = {
@@ -344,7 +311,7 @@ export function apply(ctx) {
       query: queryText.slice(0, 400),
       queryTokens: [...queryTokens].slice(0, 40),
       candidates,
-      threshold: THRESHOLD,
+      threshold: threshold(),
       injected: chosen.map((entry) => entry.experience.id),
       injectionId: null,
       scores: Object.fromEntries(chosen.map((entry) => [entry.experience.id, entry.score])),
@@ -553,10 +520,11 @@ export function apply(ctx) {
   function noteGatedFailure(trace) {
     try {
       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)
+        const score = scoreExperience(existing, queryTokens, index)
         if (score >= CONFIG.mergeThreshold && (!best || score > best.score)) best = { existing, score }
       }
       if (best) noteEvidence(best.existing, trace, 'failure', false, C.summarizeCalls(trace.calls || []))
@@ -575,7 +543,8 @@ export function apply(ctx) {
         (item) => item.source && item.source.auto && String(item.source.at || '').slice(0, 10) === today,
       ).length
 
-      const gate = C.shouldCapture(trace, { todayAdded, autoTotal }, CONFIG)
+      const intent = R.intentOf(trace.query || '')
+      const gate = C.shouldCapture(trace, { todayAdded, autoTotal }, CONFIG, intent)
       if (!gate.ok) {
         outcome.reason = gate.reason
         if (String(gate.reason).startsWith('G3')) noteGatedFailure(trace)
@@ -586,7 +555,13 @@ export function apply(ctx) {
 
       const draft = C.buildCandidate(
         trace,
-        { cwd: workspaceOf(agent), sessionId: trace.sessionId, agentId: trace.sessionId, turn: trace.turn },
+        {
+          cwd: workspaceOf(agent),
+          sessionId: trace.sessionId,
+          agentId: trace.sessionId,
+          turn: trace.turn,
+          runOnly: Boolean(gate.runOnly),
+        },
         CONFIG,
       )
 
@@ -603,7 +578,7 @@ export function apply(ctx) {
       }
 
       // G7: the capture has to read as a recipe, not as shell transcript fragments.
-      const quality = C.gateStepQuality(trace, draft, CONFIG)
+      const quality = C.gateStepQuality(trace, draft, CONFIG, intent)
       if (!quality.ok) {
         trace.skipReason = quality.reason
         outcome.reason = quality.reason
@@ -622,14 +597,25 @@ export function apply(ctx) {
       }
 
       const queryTokens = tokens([draft.title, draft.taskType, draft.when, (draft.keywords || []).join(' ')].join(' '))
+      const index = R.corpus(store.experiences)
       const sameScope = (record) => !CONFIG.scopeMustMatch || !C.scopeConflicts(record, draft)
       const mergeable = ['verified', 'auto-verified', 'candidate']
       const runSteps = C.summarizeCalls(trace.calls || [])
 
+      // Intent classes must agree: a "run this pipeline" task is not the same
+      // job as "write a new function", whatever words they share.
+      let intentVeto = null
+      const intentBlocked = (existing) => {
+        if (!R.intentConflict(existing, draft)) return false
+        if (!intentVeto) intentVeto = { id: existing.id, a: R.intentOf(existing), b: R.intentOf(draft) }
+        return true
+      }
+
       let fpBest = null
       for (const existing of store.experiences) {
         if (!mergeable.includes(existing.status)) continue
         if (!sameScope(existing)) continue
+        if (intentBlocked(existing)) continue
         if (!C.fingerprintsMatch(existing, draft)) continue
         if (!fpBest) fpBest = existing
       }
@@ -639,13 +625,28 @@ export function apply(ctx) {
         if (!mergeable.includes(existing.status)) continue
         if (!sameScope(existing)) continue
         if (existing.taskType && draft.taskType && existing.taskType !== draft.taskType) continue
-        const score = scoreExperience(existing, queryTokens)
+        if (intentBlocked(existing)) continue
+        const score = scoreExperience(existing, queryTokens, index)
         if (score >= CONFIG.mergeThreshold && (!best || score > best.score)) best = { existing, score }
       }
       if (best && CONFIG.scopeMustMatch && C.scopeConflicts(best.existing, draft)) best = null
 
       // A fingerprint match is the stronger evidence: same artifact, green tests.
       // Prefer it over a lexical score so the run is recorded as byFingerprint.
+      // Artifact-type veto applies to lexical merges too, not just fingerprints.
+      let typeVeto = null
+      if (best && C.artifactTypesConflict(best.existing, draft)) {
+        typeVeto = {
+          id: best.existing.id,
+          score: best.score,
+          kinds: [
+            (best.existing.fingerprint && best.existing.fingerprint.kinds) || [],
+            (draft.fingerprint && draft.fingerprint.kinds) || [],
+          ],
+        }
+        best = null
+      }
+
       const target = fpBest
         ? { existing: fpBest, score: 0, byFingerprint: true }
         : best
@@ -674,7 +675,7 @@ export function apply(ctx) {
       noteEvidence(created, trace, 'success', Boolean(draft.fingerprint && draft.fingerprint.green), runSteps)
       outcome.ok = true
       outcome.id = id
-      outcome.reason = `新建 ${id}（scope ${(draft.scope || []).join(',') || '未知'}；指纹 ${((draft.fingerprint && draft.fingerprint.targets) || []).join(',') || '无'}${draft.fingerprint && draft.fingerprint.green ? ' 全绿' : ''}）`
+      outcome.reason = `新建 ${id}（scope ${(draft.scope || []).join(',') || '未知'}；指纹 ${((draft.fingerprint && draft.fingerprint.targets) || []).join(',') || '无'}${draft.fingerprint && draft.fingerprint.green ? ' 全绿' : ''}${intentVeto ? `；意图不同（${intentVeto.a} vs ${intentVeto.b}），不并入 ${intentVeto.id}` : ''}${typeVeto ? `；产物类型不同（${typeVeto.kinds[0].join(',') || '无'} vs ${typeVeto.kinds[1].join(',') || '无'}），不并入 ${typeVeto.id}（相似度 ${typeVeto.score}）` : ''}）`
       outcome.ms = Math.round(performance.now() - started)
       persist()
       return outcome
@@ -830,6 +831,39 @@ export function apply(ctx) {
     },
   })
 
+  ctx.tools.register({
+    name: 'experience_archive',
+    description:
+      'Move an experience out of the active library into store.archive (reversible with /memory restore <id>). ' +
+      'Use for records a human explicitly asked to remove; it never deletes data.',
+    parameters: {
+      id: { type: 'string', required: true, description: 'Experience id, e.g. exp-22' },
+      reason: { type: 'string', description: 'Why this record is being archived' },
+    },
+    output: {
+      schema: { type: 'string' },
+      render: (_args, value) => [{ type: 'text', text: String(value) }],
+    },
+    async execute(args) {
+      const index = store.experiences.findIndex((item) => item.id === args.id)
+      if (index < 0) return `未找到 ${args.id}`
+      const [target] = store.experiences.splice(index, 1)
+      store.archive = store.archive || []
+      store.archive.push({ ...target, archivedAt: new Date().toISOString() })
+      store.evictions = store.evictions || []
+      store.evictions.push({
+        id: target.id,
+        at: new Date().toISOString(),
+        by: 'human-request',
+        reason: String(args.reason || '人工要求移出活动库'),
+        rank: null,
+        ageDays: null,
+      })
+      persist()
+      return `已归档 ${target.id}（${target.title}）；活动库剩 ${store.experiences.length} 条，可用 /memory restore ${target.id} 恢复。`
+    },
+  })
+
   ctx.tools.register({
     name: 'experience_review',
     description:
@@ -867,7 +901,7 @@ export function apply(ctx) {
       const head = [
         `store: ${STORE_FILE}`,
         `build: ${BUILD}  config: ${JSON.stringify(CONFIG)}`,
-        `experiences: ${store.experiences.length} (verified ${store.experiences.filter((item) => item.status === 'verified').length}, auto-verified ${store.experiences.filter((item) => item.status === 'auto-verified').length}, candidate ${store.experiences.filter((item) => item.status === 'candidate').length}, auto-captured ${store.experiences.filter((item) => item.source && item.source.auto).length})`,
+        `experiences: ${store.experiences.filter((x) => x.status !== 'rejected').length} (verified ${store.experiences.filter((item) => item.status === 'verified').length}, auto-verified ${store.experiences.filter((item) => item.status === 'auto-verified').length}, candidate ${store.experiences.filter((item) => item.status === 'candidate').length}, rejected ${store.experiences.filter((x) => x.status === 'rejected').length}, auto-captured ${store.experiences.filter((item) => item.source && item.source.auto).length})`,
         `injections: ${store.injections.length}  turns: ${store.turns.length}  captures: ${captures.length}  avgCaptureMs: ${avgMs}`,
         `lastInjection: ${lastInjection ? `${lastInjection.id} nonce=${lastInjection.nonce} rendered=${lastInjection.rendered} tokens=${lastInjection.tokens} ids=${lastInjection.experienceIds.join(',')}` : '-'}`,
         '',
@@ -958,9 +992,20 @@ export function apply(ctx) {
       switch (verb) {
         case '':
         case 'list': {
-          if (!store.experiences.length) return ok('档案为空。用 /memory teach 或让 agent 调用 experience_record 记录第一条。')
+          const showAll = /^(--all|all)$/.test(String(arg || '').trim())
+          const visible = showAll ? store.experiences : store.experiences.filter((item) => item.status !== 'rejected')
+          const rejectedCount = store.experiences.filter((item) => item.status === 'rejected').length
+          if (!visible.length) {
+            return ok(
+              store.experiences.length
+                ? `活动库为空；${rejectedCount} 条 rejected 记录只作审计（/memory list --all 查看）。`
+                : '档案为空。用 /memory teach 或让 agent 调用 experience_record 记录第一条。',
+            )
+          }
+          const header = !showAll && rejectedCount ? `（另有 ${rejectedCount} 条 rejected 已隐藏：/memory list --all）\n` : ''
           return ok(
-            store.experiences
+            header +
+            visible
               .map((item) => {
                 const origin = item.source && item.source.auto ? 'auto' : 'manual'
                 const count = (item.reverse_examples || item.pitfalls || []).length
@@ -1079,7 +1124,7 @@ export function apply(ctx) {
           const lines = [
             `store: ${STORE_FILE}`,
             `build: ${BUILD}  config: ${JSON.stringify(CONFIG)}`,
-            `experiences: ${store.experiences.length} (verified ${store.experiences.filter((i) => i.status === 'verified').length}, auto-verified ${store.experiences.filter((i) => i.status === 'auto-verified').length}, candidate ${store.experiences.filter((i) => i.status === 'candidate').length}, auto-captured ${store.experiences.filter((i) => i.source && i.source.auto).length})`,
+            `experiences: ${store.experiences.filter((x) => x.status !== 'rejected').length} (verified ${store.experiences.filter((i) => i.status === 'verified').length}, auto-verified ${store.experiences.filter((i) => i.status === 'auto-verified').length}, candidate ${store.experiences.filter((i) => i.status === 'candidate').length}, rejected ${store.experiences.filter((x) => x.status === 'rejected').length}, auto-captured ${store.experiences.filter((i) => i.source && i.source.auto).length})`,
             `injections: ${store.injections.length}  turns: ${store.turns.length}  captures: ${captures.length}  avgCaptureMs: ${avgMs}`,
             `lastInjection: ${lastInjection ? `${lastInjection.id} nonce=${lastInjection.nonce} rendered=${lastInjection.rendered} tokens=${lastInjection.tokens} ids=${lastInjection.experienceIds.join(',')}` : '-'}`,
             '',
@@ -1160,10 +1205,15 @@ export function apply(ctx) {
       '[1 存储] ' + pass(store.experiences.length > 0),
       '[2 可召回] ' + pass(verified.length > 0) + ` (verified=${verified.length})`,
       '[2.5 证据] ' + evidenceLine(turn),
-      '[2.6 衰减] ' + ((turn.candidates || []).map((c) => {
-        const record = store.experiences.find((item) => item.id === c.id)
-        return record ? D.decayLine(record, Date.now(), CONFIG) : `${c.id} (已不在库)`
-      }).join(' | ') || '(空)'),
+      '[2.6 衰减] ' + ((turn.candidates || [])
+        .filter((c) => {
+          const record = store.experiences.find((item) => item.id === c.id)
+          return !record || record.status !== 'rejected'
+        })
+        .map((c) => {
+          const record = store.experiences.find((item) => item.id === c.id)
+          return record ? D.decayLine(record, Date.now(), CONFIG) : `${c.id} (已不在库)`
+        }).join(' | ') || '(空)'),
       `[3 检索] ${injection ? 'PASS' : 'FAIL'} (top=${(turn.candidates && turn.candidates[0] && turn.candidates[0].score) ?? 0}, 阈值 ${turn.threshold})`,
       `[4 注入] ${injection ? (injection.rendered ? 'PASS' : 'FAIL: 已选择但 prompt 未重新读取（refreshContext 未触发）') : 'FAIL: 没有选择任何经验'}`,
       `[5 模型可见] 人工核对：回答中是否回显 nonce ${injection ? injection.nonce : '(无)'}`,