dsh-experience 1.0.8 → 1.0.14

package/CHANGELOG.md

@@ -1,5 +1,124 @@
 # 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 测试与持久化回归
 
 ### 新增

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)。
 
 ## 配置
 
@@ -141,7 +141,7 @@ plugin_manager install_bundle target=link:<PATH-TO-dsh-experience>
 ## 开发
 
 ```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

@@ -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 = 'r15-store-tests'
+const BUILD = 'r20-scope-tools'
 
 let CONFIG = { ...C.DEFAULT_CONFIG }
 
@@ -82,6 +82,23 @@ function loadStore() {
   // 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
 }
@@ -526,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)
@@ -537,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,
       )
 
@@ -554,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
@@ -578,10 +602,20 @@ export function apply(ctx) {
       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
       }
@@ -591,6 +625,7 @@ export function apply(ctx) {
         if (!mergeable.includes(existing.status)) continue
         if (!sameScope(existing)) continue
         if (existing.taskType && draft.taskType && existing.taskType !== draft.taskType) continue
+        if (intentBlocked(existing)) continue
         const score = scoreExperience(existing, queryTokens, index)
         if (score >= CONFIG.mergeThreshold && (!best || score > best.score)) best = { existing, score }
       }
@@ -598,6 +633,20 @@ export function apply(ctx) {
 
       // 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
@@ -626,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
@@ -852,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(',')}` : '-'}`,
         '',
@@ -943,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
@@ -1064,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(',')}` : '-'}`,
             '',
@@ -1145,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 : '(无)'}`,

package/lib/capture.js

@@ -198,7 +198,58 @@ export function effectiveSteps(calls) {
   return count
 }
 
-const ACTION_VERBS = /^(新增|写|跑通|修改|修复|重构|实现|添加|删除|更新|重命名|移动|替换|补|加|改为)/
+const ACTION_VERBS = /^(新增|写|跑通|跑|执行|修改|修复|重构|实现|添加|删除|更新|重命名|移动|替换|补|加|改为)/
+
+/**
+ * Executions worth repeating. A run recipe is "how to invoke this thing", so a
+ * bare mkdir / dir listing / file read never counts: those describe discovery,
+ * not the recipe.
+ */
+export function runSteps(calls) {
+  const kept = []
+  for (const call of calls || []) {
+    if (!call || !call.ok) continue
+    if (classify(call).kind !== 'run') continue
+    if (stepPriority(call) < 2) continue
+    if (isNoiseStep(stepLabel(call))) continue
+    kept.push(call)
+  }
+  return kept
+}
+
+/** The program a run call actually launched: "& \"C:\\...\\node.exe\" x.mjs" -> node. */
+export function commandHeads(calls) {
+  const heads = []
+  for (const call of calls || []) {
+    if (!call || !call.ok) continue
+    if (classify(call).kind !== 'run') continue
+    if (isNoiseStep(stepLabel(call))) continue
+    const raw = firstString(call && (call.hint || call.argsHint || call.args)) || ''
+    const lead = raw.trim().replace(/^&\s*/, '')
+    const quoted = lead.match(/^("[^"]+"|'[^']+'|\S+)/)
+    const program = quoted ? quoted[0].replace(/^["']|["']$/g, '') : ''
+    const base = program.split(/[\\/]+/).filter(Boolean).pop() || ''
+    const head = base.replace(/\.exe$/i, '').toLowerCase()
+    if (head && /^[a-z][a-z0-9_.-]*$/.test(head) && !/^[a-z]:$/.test(head)) heads.push(head)
+  }
+  return [...new Set(heads)].sort()
+}
+
+/** The script a run recipe executes, as a bare name: "run build.mjs" -> build. */
+export function runArtifactName(calls) {
+  for (const call of calls || []) {
+    if (!call || !call.ok) continue
+    if (classify(call).kind !== 'run') continue
+    const raw = firstString(call && (call.hint || call.argsHint || call.args)) || ''
+    const hit = raw.match(/[A-Za-z0-9_][A-Za-z0-9_.-]*\.(?:mjs|cjs|js|py|go|rs|sh|ps1|java)\b/i)
+    if (!hit) continue
+    const base = hit[0].split(/[\\/]/).pop()
+    return base.replace(/\.[^.]+$/, '')
+  }
+  return ''
+}
+
+
 
 /** The object of a title must name a concrete artifact, not only <placeholders>. */
 export function actionableTitle(title) {
@@ -220,15 +271,19 @@ export function actionableTitle(title) {
  * G7 — refuses captures whose steps or title are not a reusable recipe.
  * Runs after the G1..G6 chain; the caller writes trace.skipReason = reason.
  */
-export function gateStepQuality(trace, record, config) {
+export function gateStepQuality(trace, record, config, intent) {
   const cfg = { ...DEFAULT_CONFIG, ...(config || {}) }
   const calls = (trace && trace.calls) || []
-  const effective = effectiveSteps(calls)
+  // Two scales: a change is judged by its write/test steps, an invocation
+  // recipe by its repeatable executions. mkdir/read never enter either count.
+  const effective = intent === 'run' ? runSteps(calls).length : effectiveSteps(calls)
   if (effective < cfg.minEffectiveSteps) {
+    const what = intent === 'run' ? '可复用执行（建目录/读文件不计）' : '（只有写操作与测试执行算核心步骤）'
     return {
       ok: false,
-      reason: `G7: 有效步骤 ${effective} < ${cfg.minEffectiveSteps}（只有写操作与测试执行算核心步骤）`,
+      reason: `G7: 有效步骤 ${effective} < ${cfg.minEffectiveSteps}${intent === 'run' ? ' 次' : ''}${what}`,
       effective,
+      runOnly: intent === 'run',
     }
   }
   const title = String((record && record.title) || '')
@@ -262,6 +317,46 @@ export function summarizeCalls(calls) {
  * A second run that only re-reads and re-runs the tests has the same fingerprint
  * as the first run that scaffolded everything — that is the real "same task".
  */
+const EXT_KIND = {
+  code: ['js', 'mjs', 'cjs', 'ts', 'tsx', 'jsx', 'py', 'go', 'rs', 'java', 'cs', 'rb', 'php', 'sh', 'ps1', 'cmd', 'bat'],
+  image: ['png', 'jpg', 'jpeg', 'webp', 'gif', 'bmp', 'svg', 'tif', 'tiff', 'ico', 'heic'],
+  doc: ['md', 'txt', 'pdf', 'docx', 'doc', 'pptx', 'xlsx', 'csv', 'html', 'css', 'json', 'yml', 'yaml'],
+  binary: ['zip', 'gz', 'tgz', 'exe', 'dll', 'whl', 'jar'],
+}
+
+const KIND_BY_EXT = (() => {
+  const map = new Map()
+  for (const [kind, exts] of Object.entries(EXT_KIND)) for (const ext of exts) map.set(ext, kind)
+  return map
+})()
+
+export function artifactKindOf(target) {
+  const name = String(target || '').toLowerCase()
+  const match = name.match(/\.([a-z0-9]+)$/)
+  if (!match) return ''
+  return KIND_BY_EXT.get(match[1]) || ''
+}
+
+export function artifactKindsOf(targets) {
+  const kinds = new Set()
+  for (const target of targets || []) {
+    const kind = artifactKindOf(target)
+    if (kind) kinds.add(kind)
+  }
+  return [...kinds].sort()
+}
+
+/**
+ * Do these two runs write fundamentally different kinds of artifact?
+ * Only says "conflict" when both sides have evidence and the sets are disjoint.
+ */
+export function artifactTypesConflict(left, right) {
+  const a = (left && left.fingerprint && left.fingerprint.kinds) || []
+  const b = (right && right.fingerprint && right.fingerprint.kinds) || []
+  if (!a.length || !b.length) return false
+  return !a.some((kind) => b.includes(kind))
+}
+
 export function outcomeFingerprint(calls) {
   const list = calls || []
   const artifactOf = (call) => {
@@ -277,9 +372,12 @@ export function outcomeFingerprint(calls) {
   // A run that failed and then went green still ends green; the failure itself is
   // captured as a reverse example, not as a reason to refuse the merge.
   const green = testCalls.length > 0 && testCalls[testCalls.length - 1].ok === true
-  const artifacts = (writes.length ? writes : reads).filter(isCode)
+  const allArtifacts = writes.length ? writes : reads
+  const artifacts = allArtifacts.filter(isCode)
   return {
     targets: [...new Set(artifacts)].sort(),
+    commands: commandHeads(list),
+    kinds: artifactKindsOf(allArtifacts),
     tests: [...new Set(tests)].sort(),
     green,
     verificationOnly: writes.length === 0,
@@ -291,6 +389,8 @@ export function fingerprintsMatch(left, right) {
   const a = left && left.fingerprint
   const b = right && right.fingerprint
   if (!a || !b || !a.green || !b.green) return false
+  // Same name, different artifact type is not the same outcome.
+  if (artifactTypesConflict(left, right)) return false
   const have = new Set(a.targets || [])
   const want = new Set(b.targets || [])
   if (!have.size || !want.size) return false
@@ -376,7 +476,7 @@ export function inferTaskType(calls, cwd) {
   return 'workspace/general'
 }
 
-export function shouldCapture(trace, counts, config) {
+export function shouldCapture(trace, counts, config, intent) {
   const cfg = { ...DEFAULT_CONFIG, ...(config || {}) }
   const calls = (trace && trace.calls) || []
   const successes = calls.filter((call) => call && call.ok)
@@ -395,7 +495,11 @@ export function shouldCapture(trace, counts, config) {
   const tests = successes.filter((call) => isTestCall(call))
   const testFailures = calls.filter((call) => call && !call.ok && isTestCall(call))
   const verifiedGreen = tests.length > 0 && testFailures.length === 0
-  if (!writes.length && !recoveries.length && !verifiedGreen) {
+  // A run recipe is legitimate evidence on its own: nobody wrote anything, but
+  // the execution was repeated and is worth replaying.
+  const executions = intent === 'run' ? runSteps(calls) : []
+  const runOnly = intent === 'run' && !writes.length && !recoveries.length && !verifiedGreen
+  if (!writes.length && !recoveries.length && !verifiedGreen && !(runOnly && executions.length >= 2)) {
     return { ok: false, reason: 'G3: 无成功写操作、无失败后成功，且不是全绿验证轨迹' }
   }
 
@@ -405,7 +509,14 @@ export function shouldCapture(trace, counts, config) {
   if ((counts && counts.autoTotal) >= cfg.libraryLimit) {
     return { ok: false, reason: `G5: 自动经验库已达上限 ${cfg.libraryLimit}` }
   }
-  return { ok: true, writes, recoveries, verificationOnly: !writes.length && !recoveries.length }
+  return {
+    ok: true,
+    writes,
+    recoveries,
+    runOnly,
+    executions: executions.length,
+    verificationOnly: !writes.length && !recoveries.length,
+  }
 }
 
 function verbsOf(taskType) {
@@ -424,7 +535,12 @@ export function workspaceName(cwd) {
 
 const GENERIC_DIRS = new Set([
   'users', 'home', 'desktop', 'documents', 'downloads', 'src', 'test', 'tests',
-  'lib', 'node_modules', 'bin', 'tmp', 'temp', 'app', 'apps', 'workspace', 'workspaces',
+  'lib', 'node_modules', 'bin', 'tmp', 'temp', 'app', 'apps', 'workspace',
+  'workspaces',
+  // Tool-chain directories: every recipe on this machine touches them, so they
+  // 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',
 ])
 
 /**
@@ -482,9 +598,14 @@ export function scopeOf(record) {
 }
 
 /** Two records describe different targets when both name a project dir and the names disagree. */
+/** Scope tokens that actually name a project, not the tool-chain around it. */
+export function projectScope(record) {
+  return scopeOf(record).filter((item) => item.length >= 2 && !GENERIC_DIRS.has(item))
+}
+
 export function scopeConflicts(existing, draft) {
-  const left = scopeOf(existing)
-  const right = scopeOf(draft)
+  const left = projectScope(existing)
+  const right = projectScope(draft)
   if (!left.length || !right.length) return false
   return !left.some((item) => right.includes(item))
 }
@@ -506,14 +627,29 @@ export function buildCandidate(trace, info, config) {
   const writes = calls.filter((call) => call && call.ok && classify(call).kind === 'write')
   const runs = calls.filter((call) => call && call.ok && classify(call).kind === 'run')
 
+  const runOnly = Boolean(info && info.runOnly) || (!writes.length && runs.length > 0)
   const primary = writes.length ? classify(writes[0]).target : runs.length ? classify(runs[0]).target : ''
+  const scriptName = runOnly ? runArtifactName(calls) : ''
   const verb = writes.length ? '写' : '跑通'
   // Prefer a concrete artifact name (raw basename, before path normalization):
   // "<path>/<name>.js" cannot name what was produced, "slugify.js" can.
   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))
-  const title = clip(named ? `新增 ${named}` : primary ? `${verb} ${primary}` : verbsOf(taskType), 110)
+  const title = clip(
+    runOnly
+      ? scriptName
+        ? `跑 ${scriptName}`
+        : primary
+          ? `跑 ${primary}`
+          : verbsOf(taskType)
+      : named
+        ? `新增 ${named}`
+        : primary
+          ? `${verb} ${primary}`
+          : verbsOf(taskType),
+    110,
+  )
   const place = workspaceName(info && info.cwd)
   const when = clip(place ? `在 ${place} 里 ${verbsOf(taskType)}` : `当需要${verbsOf(taskType)}时`, 160)
   const keywords = [...new Set([taskType, ...steps.map((step) => step.split(' ')[1] || '').filter(Boolean)])]

package/lib/decay.js

@@ -127,7 +127,7 @@ 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' && !isPinned(record))
+    .filter((record) => record && record.status !== 'verified' && record.status !== 'rejected' && !isPinned(record))
     .map((record) => ({ record, info: stateOf(record, now, config) }))
     .filter((entry) => entry.info.dormant)
     .sort((left, right) => left.info.rank - right.info.rank)
@@ -178,9 +178,13 @@ export function decayLine(record, now = Date.now(), config = {}) {
 
 export function renderDecayReport(store, now = Date.now(), config = {}) {
   const records = Array.isArray(store && store.experiences) ? store.experiences : []
-  const proposal = selectEvictions(records, now, config)
+  // Rejected records are kept as an audit trail: they cannot be recalled, merged
+  // or evicted, so counting them would only distort the capacity numbers.
+  const hiddenRejected = records.filter((record) => record && record.status === 'rejected').length
+  const live = records.filter((record) => record && record.status !== 'rejected')
+  const proposal = selectEvictions(live, now, config)
   const counts = { active: 0, dormant: 0, pinned: 0 }
-  const sorted = records
+  const sorted = live
     .map((record) => ({ record, info: stateOf(record, now, config) }))
     .sort((left, right) => {
       if (left.info.pinned !== right.info.pinned) return left.info.pinned ? 1 : -1
@@ -193,7 +197,8 @@ export function renderDecayReport(store, now = Date.now(), config = {}) {
   const eligible = new Set(proposal.evictions.map((item) => item.id))
   const top = sorted.filter((entry) => !entry.info.pinned).slice(0, 5)
   const lines = [
-    `[M3.3 衰减报告] 库 ${records.length} 条 · active ${counts.active} / dormant ${counts.dormant} / pinned ${counts.pinned}`,
+    `[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 升序）:`

package/lib/recall.js

@@ -110,6 +110,31 @@ const round = (value) => Math.round(value * 1000) / 1000
  * "MODULE_NOT_FOUND") discriminate; common ones ("报错", "模块") must not.
  * Without this, a noisy task description lifts every record at once.
  */
+/**
+ * Which kind of task is this: running something, or writing something?
+ * Empty means "cannot tell" and never vetoes anything.
+ */
+export function intentOf(experienceOrText) {
+  const text =
+    typeof experienceOrText === 'string' ? experienceOrText : profileText(experienceOrText)
+  const found = features(text)
+  const run = found.has('#run')
+  const write = found.has('#write')
+  if (run && !write) return 'run'
+  if (write && !run) return 'write'
+  return ''
+}
+
+/**
+ * "run the image pipeline" and "add a helper function" are different tasks even
+ * when they share every noun; only verdicts with evidence on both sides count.
+ */
+export function intentConflict(left, right) {
+  const a = intentOf(left)
+  const b = intentOf(right)
+  return Boolean(a && b && a !== b)
+}
+
 export function corpus(experiences) {
   const df = new Map()
   let n = 0

package/package.json

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

package/tools/e2e.mjs

@@ -322,6 +322,94 @@ await test('T58 superseded is never recalled and never re-captured', async () =>
   assert.match(String(turn.capture && turn.capture.reason), /G8/, `expected G8, got ${JSON.stringify(turn.capture)}`);
 });
 
+await test('T59 a run recipe never absorbs a write task', async () => {
+  const created = await tools.get('experience_record').execute(
+    {
+      title: '运行 node 脚本并抓退出码',
+      taskType: 'node/run',
+      when: '需要在 DSH 里跑 .mjs 脚本时',
+      keywords: ['acme-run', 'node', 'run'],
+      steps: ['跑 node tools/run.mjs', '读 EXIT'],
+      pitfalls: ['PATH 里没有 node，报 CommandNotFoundException'],
+    },
+    { agent: A },
+  )
+  const id = String(created).match(/exp-\d+/)[0]
+  const approved = await cmd(`approve ${id}`)
+  assert.equal(approved.kind, 'success', approved.text)
+
+  await enter(A, 21, 1, '在 src 里新增 quux 函数并配 node:test 用例')
+  await call(A, 'write', { file_path: 'D:\\work\\acme-run\\src\\quux.js' })
+  await call(A, 'write', { file_path: 'D:\\work\\acme-run\\test\\quux.test.mjs' })
+  await call(A, 'pwsh', { command: 'node test\\quux.test.mjs' })
+  await fire('agent/turn-stopping', { agent: A, turn: 21, signal: undefined })
+
+  const turn = readStore().turns.at(-1)
+  assert.ok(!turn.capture.merged, 'must not merge across intent classes')
+  assert.match(String(turn.capture.reason), /意图不同/, `reason: ${turn.capture.reason}`)
+})
+
+await test('T60 rejected records are hidden from list unless --all', async () => {
+  const created = await tools.get('experience_record').execute(
+    {
+      title: '新增 throwaway',
+      taskType: 'node-project/feature',
+      when: '一次性的试验任务',
+      keywords: ['throwaway'],
+      steps: ['写 a.js', '跑 a.js'],
+      pitfalls: [],
+    },
+    { agent: A },
+  )
+  const id = String(created).match(/exp-\d+/)[0]
+  const rejected = await cmd(`reject ${id}`)
+  assert.equal(rejected.kind, 'success', rejected.text)
+
+  const plain = await cmd('list')
+  assert.ok(!plain.text.includes(id), 'rejected hidden by default')
+  assert.match(plain.text, /rejected 已隐藏|--all/)
+
+  const all = await cmd('list --all')
+  assert.ok(all.text.includes(id), '--all shows the audit trail')
+
+  const debug = await tools.get('experience_debug').execute({}, { agent: A })
+  assert.match(debug, /rejected 1/)
+})
+
+await test('T61 a run-only turn becomes a run recipe', async () => {
+  await enter(A, 22, 1, '运行 D:\\work\\acme-run\\run.mjs 看输出')
+  await call(A, 'pwsh', { command: '& "C:\\Users\\dev\\node.exe" "D:\\work\\acme-run\\run.mjs"' })
+  await call(A, 'pwsh', { command: '& "C:\\Users\\dev\\node.exe" "D:\\work\\acme-run\\run.mjs"' })
+  await fire('agent/turn-stopping', { agent: A, turn: 22, signal: undefined })
+
+  const turn = readStore().turns.at(-1)
+  assert.equal(turn.capture.ok, true, JSON.stringify(turn.capture))
+  const withNode = readStore().experiences.filter((e) => ((e.fingerprint && e.fingerprint.commands) || []).includes('node'))
+  assert.ok(withNode.length >= 1, 'no record carries the node command head')
+})
+
+await test('T62 the same recipe in a second project stays separate', async () => {
+  await enter(A, 30, 1, '在 acme-one 里新增 lerp 函数并配 node:test 用例')
+  await call(A, 'write', { file_path: 'D:\\work\\acme-one\\src\\lerp.js' })
+  await call(A, 'write', { file_path: 'D:\\work\\acme-one\\test\\lerp.test.mjs' })
+  await call(A, 'pwsh', { command: 'node test\\lerp.test.mjs' })
+  await fire('agent/turn-stopping', { agent: A, turn: 30, signal: undefined })
+  const first = readStore().turns.at(-1).capture
+  assert.equal(first.ok, true, JSON.stringify(first))
+  const firstId = first.id
+  assert.ok(firstId, 'first project did not create a record')
+
+  await enter(A, 31, 1, '在 acme-two 里新增 lerp 函数并配 node:test 用例')
+  await call(A, 'write', { file_path: 'D:\\work\\acme-two\\src\\lerp.js' })
+  await call(A, 'write', { file_path: 'D:\\work\\acme-two\\test\\lerp.test.mjs' })
+  await call(A, 'pwsh', { command: 'node test\\lerp.test.mjs' })
+  await fire('agent/turn-stopping', { agent: A, turn: 31, signal: undefined })
+
+  const second = readStore().turns.at(-1).capture
+  assert.notEqual(second.merged, firstId, 'the second project must not merge into the first')
+  assert.match(String(second.reason), /scope 不同|意图不同|按新任务/, `reason: ${second.reason}`)
+})
+
 console.log('');
 let pass = 0;
 results.forEach((item, index) => {

package/tools/selftest.mjs

@@ -1025,6 +1025,165 @@ test('T71 a corrupt store degrades instead of throwing', () => {
   fs.rmSync(dir, { recursive: true, force: true })
 })
 
+test('T72 a .png outcome never fingerprint-matches a .py recipe', () => {
+  const python = {
+    fingerprint: { targets: ['_img_edit/cand.py'], kinds: ['code', 'image'], green: true },
+  }
+  const pngOnly = {
+    fingerprint: { targets: ['_img_edit/cand.py'], kinds: ['image'], green: true },
+  }
+  const imageOnly = { fingerprint: { targets: ['out/result.png'], kinds: ['image'], green: true } }
+  const pythonOnly = { fingerprint: { targets: ['lib/mod.py'], kinds: ['code'], green: true } }
+
+  // same green flag and an overlapping target is not enough: types must overlap too
+  assert.equal(C.fingerprintsMatch(pythonOnly, imageOnly), false, '.py must not merge a .png run')
+  assert.equal(C.artifactTypesConflict(pythonOnly, imageOnly), true)
+  // overlapping kinds (a run that touched both) still merges
+  assert.equal(C.artifactTypesConflict(python, pngOnly), false)
+})
+
+test('T73 artifactTypesConflict only vetoes when both sides carry evidence', () => {
+  const code = { fingerprint: { targets: ['src/a.js'], kinds: ['code'], green: true } }
+  const otherCode = { fingerprint: { targets: ['src/b.js'], kinds: ['code'], green: true } }
+  const unknown = { fingerprint: { targets: ['<path>'], kinds: [], green: true } }
+  const noFingerprint = {}
+  assert.equal(C.artifactTypesConflict(code, otherCode), false, 'same kind never conflicts')
+  assert.equal(C.artifactTypesConflict(code, unknown), false, 'unknown side must not veto')
+  assert.equal(C.artifactTypesConflict(code, noFingerprint), false, 'legacy record must not veto')
+})
+
+test('T74 outcomeFingerprint records the artifact kinds it saw', () => {
+  const call = (hint) => ({ name: 'write', hint, ok: true })
+  const py = C.outcomeFingerprint([call('D:/work/_img_edit/cand.py'), call('D:/work/_img_edit/out.png')])
+  assert.deepEqual(py.kinds, ['code', 'image'], 'both kinds recorded')
+  assert.deepEqual(py.targets, ['_img_edit/cand.py'], 'targets stay code-only for fingerprints')
+
+  const images = C.outcomeFingerprint([call('D:/work/out/a.png'), call('D:/work/out/b.jpg')])
+  assert.deepEqual(images.kinds, ['image'])
+  assert.deepEqual(images.targets, [], 'image-only run has no code targets')
+
+  assert.equal(C.artifactKindOf('x.JPG'), 'image', 'extension match is case-insensitive')
+  assert.equal(C.artifactKindOf('noext'), '')
+})
+
+test('T75 intent classes keep "run a script" apart from "write a function"', () => {
+  const runRecipe = {
+    title: '运行 node 脚本并抓退出码',
+    when: '需要在 DSH 里跑 .mjs 脚本时',
+    steps: ['跑 node tools/run.mjs'],
+    keywords: ['node'],
+  }
+  const writeRecipe = {
+    title: '新增 pad 函数并配用例',
+    when: '需要加一个纯函数时',
+    steps: ['写 src/pad.js'],
+    keywords: ['node'],
+  }
+  assert.equal(R.intentOf(runRecipe), 'run')
+  assert.equal(R.intentOf(writeRecipe), 'write')
+  assert.equal(R.intentConflict(runRecipe, writeRecipe), true)
+  assert.equal(R.intentConflict(writeRecipe, runRecipe), true)
+  assert.equal(R.intentConflict(runRecipe, runRecipe), false)
+})
+
+test('T76 an ambiguous intent never vetoes a merge', () => {
+  const vague = { title: '处理一下那个东西', steps: ['看看'] }
+  assert.equal(R.intentOf(vague), '')
+  assert.equal(R.intentConflict(vague, { title: '新增函数' }), false)
+  assert.equal(R.intentConflict({ title: '' }, { title: '' }), false)
+  const mixed = { title: '新增脚本并运行它', steps: ['写 a.mjs', '跑 a.mjs'] }
+  assert.equal(R.intentOf(mixed), '')
+  assert.equal(R.intentConflict(mixed, { title: '新增函数' }), false)
+})
+
+test('T77 rejected records are audit-only for capacity and eviction', () => {
+  const now = Date.parse('2026-11-09T00:00:00Z')
+  const old = (id, extra) => ({ id, status: 'candidate', createdAt: '2025-01-01T00:00:00Z', ...extra })
+  const store = {
+    experiences: [
+      old('keep-verified', { status: 'verified' }),
+      old('old-cand'),
+      { id: 'rej-1', status: 'rejected', createdAt: '2025-01-01T00:00:00Z', title: 'rejected noise' },
+    ],
+  }
+  const report = D.renderDecayReport(store, now, { libraryLimit: 10 })
+  assert.match(report, /库 2 条/, report.split('\n')[0])
+  assert.match(report, /已排除 1 条 rejected/)
+  assert.ok(!report.includes('rej-1'), 'rejected must not appear in ranking')
+  const proposal = D.selectEvictions(store.experiences, now, { libraryLimit: 2 })
+  assert.ok(proposal.evictions.every((item) => item.id !== 'rej-1'), 'never evict a rejected record')
+})
+
+test('T78 a pure run track is captured, titled and fingerprinted by its command', () => {
+  const calls = [
+    { name: 'pwsh', hint: 'New-Item -ItemType Directory -Path D:\\work\\acme-app\\cross-a', ok: true },
+    { name: 'pwsh', hint: '& "C:\\Users\\dev\\node.exe" "D:\\work\\acme-app\\run.mjs"', ok: true },
+    { name: 'pwsh', hint: '& "C:\\Users\\dev\\node.exe" "D:\\work\\acme-app\\run.mjs"', ok: true },
+  ]
+  const trace = { query: '运行 D:\\work\\acme-app\\run.mjs 看输出', calls }
+  const gate = C.shouldCapture(trace, { todayAdded: 0, autoTotal: 0 }, C.DEFAULT_CONFIG, 'run')
+  assert.equal(gate.ok, true, gate.reason)
+  assert.equal(gate.runOnly, true)
+  assert.equal(gate.executions, 2)
+
+  const quality = C.gateStepQuality(
+    trace,
+    { title: '跑 run', when: '当需要跑脚本时', steps: [] },
+    C.DEFAULT_CONFIG,
+    'run',
+  )
+  assert.equal(quality.ok, true, quality.reason)
+
+  const draft = C.buildCandidate(trace, { runOnly: true }, C.DEFAULT_CONFIG)
+  assert.equal(draft.title, '跑 run')
+  assert.deepEqual(draft.fingerprint.commands, ['node'])
+  assert.deepEqual(C.commandHeads(calls), ['node'])
+})
+
+test('T79 mkdir and read-only tracks still fail G3 and G7', () => {
+  const calls = [
+    { name: 'pwsh', hint: 'New-Item -ItemType Directory -Path D:\\work\\acme-app\\cross-b', ok: true },
+    { name: 'pwsh', hint: 'Get-Content D:\\work\\acme-app\\run.mjs', ok: true },
+    { name: 'pwsh', hint: 'Get-ChildItem -Force', ok: true },
+  ]
+  const trace = { query: '跑一下 run.mjs', calls }
+  const gate = C.shouldCapture(trace, { todayAdded: 0, autoTotal: 0 }, C.DEFAULT_CONFIG, 'run')
+  assert.equal(gate.ok, false)
+  assert.match(gate.reason, /G3/)
+
+  const quality = C.gateStepQuality(trace, { title: '跑 run', when: '当需要跑脚本时' }, C.DEFAULT_CONFIG, 'run')
+  assert.equal(quality.ok, false)
+  assert.match(quality.reason, /G7/)
+
+  const oneWrite = [{ name: 'write', hint: 'D:\\work\\x\\hello.js', ok: true }]
+  const writeGate = C.gateStepQuality(
+    { calls: oneWrite },
+    { title: '新增 hello', when: '当需要新增函数时' },
+    C.DEFAULT_CONFIG,
+    'write',
+  )
+  assert.equal(writeGate.ok, false, 'write tracks still need two effective steps')
+})
+
+test('T80 a shared tool-chain token does not bridge two projects', () => {
+  const left = { scope: ['cross-a', 'node'], title: '新增 math' }
+  const right = { scope: ['cross-b', 'node', 'cr'], title: '新增 math' }
+  assert.deepEqual(C.projectScope(left), ['cross-a'])
+  assert.deepEqual(C.scopeConflicts(left, right), true)
+  assert.deepEqual(C.scopeConflicts(left, { scope: ['cross-a'] }), false)
+  // A record that only knows the tool-chain stays neutral, not conflicting.
+  assert.equal(C.scopeConflicts({ scope: ['node'] }, right), false)
+})
+
+test('T81 a run recipe is always titled by its script', () => {
+  const calls = [
+    { name: 'pwsh', hint: '& "C:\\Users\\dev\\node.exe" "D:\\work\\app\\run.mjs"', ok: true },
+    { name: 'pwsh', hint: '& "C:\\Users\\dev\\node.exe" "D:\\work\\app\\run.mjs"', ok: true },
+  ]
+  const draft = C.buildCandidate({ query: '运行 run.mjs', calls }, { runOnly: true }, C.DEFAULT_CONFIG)
+  assert.equal(draft.title, '跑 run')
+})
+
 // ---------------------------------------------------------------- summary
 
 const total = pass + failures.length