dsh-experience 1.0.5 → 1.0.14

package/tools/e2e.mjs

@@ -186,7 +186,7 @@ await test('T46 decay report is read-only and restore refuses unknown ids', asyn
   const report = await cmd('decay --age 400');
   assert.equal(report.kind, 'success', report.text);
   assert.equal(readStore().experiences.length, before, 'report must not delete anything');
-  assert.equal(readStore().archive, undefined, 'nothing moved to archive');
+  assert.equal((readStore().archive || []).length, 0, 'nothing moved to archive');
   const restore = await cmd('restore exp-1');
   assert.equal(restore.kind, 'error');
   assert.match(restore.text, /archive 里没有/);
@@ -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

@@ -9,6 +9,11 @@ import * as C from '../lib/capture.js'
 import * as D from '../lib/decay.js'
 import * as E from '../lib/evidence.js'
 import * as L from '../lib/lookup.js'
+import * as R from '../lib/recall.js'
+import * as S from '../lib/store.js'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
 
 let pass = 0
 const failures = []
@@ -41,6 +46,7 @@ test('config defaults are the agreed numbers', () => {
     stepsJaccard: 0.7,
     allowAutoVerified: false,
     minEffectiveSteps: 2,
+    recallThreshold: 0.15,
   })
   assert.equal(C.DEFAULT_CONFIG.autoPromote, false, 'policy must default to off')
   assert.equal(C.DEFAULT_CONFIG.allowAutoVerified, false, 'auto-verified must never be recalled by default')
@@ -912,6 +918,272 @@ test('T62 renderReview lists rule-rejected records without offering them', () =>
   assert.match(text, /已否决.*1 条/)
 })
 
+// ---------------------------------------------------------------- recall scoring
+
+test('T63 stop words do not dilute the query', () => {
+  const noisy = R.expand('随便跑一个测试场景，故意让它报错')
+  for (const filler of ['随便', '故意', '场景', '测试场景']) {
+    assert.equal(noisy.has(filler), false, filler + ' must be dropped')
+  }
+  assert.equal(noisy.has('#error'), true, 'feature survives even though the words are dropped')
+})
+
+test('T64 vocabulary mismatch still scores through feature buckets', () => {
+  const profile = 'pwsh node.exe load_workspace_dependencies 模块 报错'
+  const query = '跑一个会踩坑的 .mjs 脚本，内置 node 模块报错'
+  const result = R.explain(profile, query)
+  assert.ok(result.score >= 0.15, 'score ' + result.score + ' must clear the default floor')
+  assert.ok(result.features.includes('#node'), 'node feature must match, got ' + result.features.join(','))
+  assert.ok(result.features.includes('#error'), 'error feature must match, got ' + result.features.join(','))
+})
+
+test('T65 unrelated query still scores near zero', () => {
+  const result = R.explain('pwsh node.exe 模块 报错', '把三张图片重命名为 image_001.png')
+  assert.ok(result.score < 0.15, 'score ' + result.score + ' must stay below the floor')
+})
+
+test('T66 score is bounded and self-match is high', () => {
+  const profile = '新增 truncate 函数 并配 node:test 用例'
+  const partial = R.score(profile, R.expand('新增 truncate 函数并配用例'))
+  const self = R.score(profile, R.expand(profile))
+  assert.ok(partial > 0.3 && partial <= 1, 'partial match scored ' + partial)
+  assert.ok(self <= 1, 'self match must not exceed 1, got ' + self)
+})
+
+test('T67 tokenizer keeps file names', () => {
+  const tokens = R.tokenize('node test/truncate.test.mjs && echo done')
+  assert.equal(tokens.has('truncate.test.mjs'), true)
+  assert.equal(tokens.has('node'), true)
+})
+
+test('T68 a query with #error favours the record that documents the failure', () => {
+  const withPitfall = {
+    id: 'exp-a',
+    title: '在 DSH 会话里运行 Node 脚本',
+    taskType: 'node/run',
+    when: '在 desktop 里 跑 .mjs 脚本验证时',
+    keywords: ['node', 'node.exe', 'PATH', 'MODULE_NOT_FOUND'],
+    pitfalls: ['require 一个不存在的模块只会得到 MODULE_NOT_FOUND 报错'],
+    reverse_examples: [],
+  }
+  const chore = {
+    id: 'exp-b',
+    title: '新增 index',
+    taskType: 'node-project/feature',
+    when: '在 desktop 里 新增函数/模块并配用例',
+    keywords: ['node', 'src/index.js', 'test/<name>.mjs'],
+    pitfalls: [],
+    reverse_examples: [],
+  }
+  const index = R.corpus([withPitfall, chore])
+  const query = R.expand('随便写个 .mjs 脚本，require 一个不存在的模块，跑一下报错，然后自己排查修复')
+  const hit = R.score(R.profileText(withPitfall), query, index)
+  const miss = R.score(R.profileText(chore), query, index)
+  assert.equal(query.has('#error'), true, 'query must carry #error')
+  assert.ok(hit > miss, `pitfall record ${hit} must beat chore ${miss}`)
+})
+
+test('T69 reload preserves archive and evictions', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'exp-store-'))
+  const file = path.join(dir, 'store.json')
+  const store = S.emptyStore()
+  store.experiences = [{ id: 'exp-1', status: 'verified', title: 'kept' }]
+  store.archive = [{ id: 'exp-9', title: 'archived' }]
+  store.evictions = [{ id: 'exp-9', by: 'human-request', at: '2026-11-09T00:00:00.000Z' }]
+  store.nextId = 10
+  S.writeStore(file, store)
+
+  const reloaded = S.readStore(file)
+  assert.equal(reloaded.error, undefined, 'clean file must load without error')
+  assert.equal(reloaded.store.experiences.length, 1)
+  assert.deepEqual(reloaded.store.archive.map((e) => e.id), ['exp-9'], 'archive must survive')
+  assert.equal(reloaded.store.evictions.length, 1, 'evictions must survive')
+  assert.equal(reloaded.store.nextId, 10, 'counters must survive')
+  fs.rmSync(dir, { recursive: true, force: true })
+})
+
+test('T70 unknown fields survive a reload', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'exp-store-'))
+  const file = path.join(dir, 'store.json')
+  fs.writeFileSync(file, JSON.stringify({ experiences: [], futureTable: [{ id: 'x' }] }), 'utf8')
+  const reloaded = S.readStore(file)
+  assert.deepEqual(reloaded.store.futureTable, [{ id: 'x' }], 'an older build must not drop new fields')
+  assert.deepEqual(reloaded.store.archive, [], 'missing archive defaults to empty')
+  fs.rmSync(dir, { recursive: true, force: true })
+})
+
+test('T71 a corrupt store degrades instead of throwing', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'exp-store-'))
+  const file = path.join(dir, 'store.json')
+  fs.writeFileSync(file, '{ not json', 'utf8')
+  const result = S.readStore(file)
+  assert.ok(result.error instanceof Error, 'error must be reported, not thrown')
+  assert.equal(result.store.experiences.length, 0, 'falls back to an empty store')
+  const missing = S.readStore(path.join(dir, 'nope.json'))
+  assert.equal(missing.missing, true)
+  assert.deepEqual(missing.store.archive, [])
+  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