dsh-experience 0.0.0-stage → 1.0.4

package/index.js

@@ -0,0 +1,1207 @@
+/**
+ * dsh-experience — cross-session experience loop for DeepSeek Harness.
+ *
+ * v0.2 M1: deterministic L1 auto-capture (no model calls) + `/memory review`.
+ *
+ * Integration points (evidenced in the DSH packages, see README):
+ *   - `agent/pre-step` (waterfall): async retrieval, cached for the step.
+ *   - `systemPrompt.context` on `agent.ctx`: its text is re-read by
+ *     `refreshContext()` after pre-step, so the cache lands in this step.
+ *   - `tools/result` (emit, observe-only): records every tool outcome with zero
+ *     dispatch latency; `tools/post-execute` is a waterfall and would be awaited.
+ *   - `agent/turn-stopping` (serial): deterministic capture + trace close.
+ *   - `tools.register` / `commands.register` / durable JSON sidecar.
+ */
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+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 { renderLookup } from './lib/lookup.js'
+
+export const name = 'dsh-experience'
+export const inject = ['tools', 'systemPrompt', 'commands', 'agents']
+
+const HOME = process.env.DSH_HOME || path.join(os.homedir(), '.dsh')
+const STORE_DIR = path.join(HOME, 'experience')
+const STORE_FILE = path.join(STORE_DIR, 'store.json')
+const CONFIG_FILE = path.join(STORE_DIR, 'config.json')
+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'
+
+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'))
+    if (raw && typeof raw === 'object') {
+      CONFIG = { ...C.DEFAULT_CONFIG, ...raw }
+      let repaired = false
+      for (const key of Object.keys(C.DEFAULT_CONFIG)) {
+        try {
+          const value = C.coerceConfigValue(key, CONFIG[key])
+          if (value !== CONFIG[key]) {
+            CONFIG[key] = value
+            repaired = true
+          }
+        } catch {}
+      }
+      if (repaired) saveConfig()
+    }
+  } catch {}
+  return CONFIG
+}
+
+function saveConfig() {
+  try {
+    fs.mkdirSync(STORE_DIR, { recursive: true })
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(CONFIG, null, 2), 'utf8')
+  } catch (error) {
+    console.warn('[experience] config write failed:', error && error.message)
+  }
+}
+
+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()
+    try {
+      fs.renameSync(STORE_FILE, `${STORE_FILE}.broken-${Date.now()}`)
+    } catch {}
+    console.warn('[experience] store unreadable, started empty:', error && error.message)
+    return emptyStore()
+  }
+}
+
+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)
+}
+
+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
+}
+
+function profileTokens(experience) {
+  return tokens([
+    experience.title,
+    experience.taskType,
+    experience.when,
+    (experience.keywords || []).join(' '),
+  ].join(' '))
+}
+
+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
+}
+
+function textOfMessage(message) {
+  if (!message) return ''
+  const content = message.content
+  if (typeof content === 'string') return content
+  if (Array.isArray(content)) {
+    return content
+      .map((block) => (block && typeof block.text === 'string' ? block.text : ''))
+      .join('\n')
+  }
+  return ''
+}
+
+function agentId(agent) {
+  if (!agent) return ''
+  if (typeof agent.id === 'string') return agent.id
+  if (agent.session && typeof agent.session.id === 'string') return agent.session.id
+  return ''
+}
+
+function estimateTokens(text) {
+  return Math.ceil(String(text || '').length / 2.5)
+}
+
+function workspaceOf(agent) {
+  const candidates = [agent && agent.session && agent.session.cwd, agent && agent.cwd, process.cwd()]
+  return candidates.find((value) => typeof value === 'string' && value) || ''
+}
+
+function pickName(exec) {
+  const candidates = [
+    exec && exec.name,
+    exec && exec.tool,
+    exec && exec.toolName,
+    exec && exec.definition && exec.definition.name,
+    exec && exec.call && exec.call.name,
+  ]
+  return candidates.find((value) => typeof value === 'string' && value) || 'unknown'
+}
+
+function pickArgs(exec) {
+  const candidates = [
+    exec && exec.arguments,
+    exec && exec.args,
+    exec && exec.input,
+    exec && exec.call && exec.call.arguments,
+    exec && exec.call && exec.call.args,
+  ]
+  return candidates.find((value) => value && typeof value === 'object') || null
+}
+
+function pickOk(exec, result) {
+  // Probe-confirmed contract (probe.json, 2026-11-08):
+  //   ToolExecution       = { name, callId, arguments, agent, toolSet, ... }
+  //   ToolExecutionResult = { isError: boolean, content: [...], value: string }
+  if (result && typeof result === 'object' && typeof result.isError === 'boolean') return !result.isError
+  if (result && typeof result === 'object') {
+    if (typeof result.ok === 'boolean') return result.ok
+    if (typeof result.success === 'boolean') return result.success
+    if (typeof result.failed === 'boolean') return !result.failed
+    if (result.error) return false
+    if (typeof result.status === 'string') return /^(ok|success|succeeded|completed|done)$/i.test(result.status)
+  }
+  if (exec && exec.error) return false
+  return true
+}
+
+function pickError(exec, result) {
+  const parts = []
+  if (result && typeof result === 'object') {
+    if (typeof result.value === 'string' && result.value) parts.push(result.value)
+    else if (Array.isArray(result.content)) {
+      for (const block of result.content) {
+        if (block && typeof block.text === 'string') parts.push(block.text)
+      }
+    }
+    if (typeof result.error === 'string') parts.push(result.error)
+    else if (result.error) parts.push(String(result.error.code || ''), String(result.error.message || ''))
+  }
+  if (exec && exec.error) {
+    if (typeof exec.error === 'string') parts.push(exec.error)
+    else parts.push(String(exec.error.code || ''), String(exec.error.message || ''))
+  }
+  return parts.filter(Boolean).join(' ').trim()
+}
+
+function hintOf(args) {
+  if (!args) return ''
+  if (typeof args === 'string') return args
+  for (const key of ['path', 'file', 'file_path', 'command', 'cmd', 'pattern', 'query', 'ids']) {
+    const value = args[key]
+    if (typeof value === 'string') return value
+    if (Array.isArray(value) && value.length) return value.map(String).join(' ')
+  }
+  try {
+    return JSON.stringify(args)
+  } catch {
+    return ''
+  }
+}
+
+export function apply(ctx) {
+  loadConfig()
+  try {
+    fs.mkdirSync(STORE_DIR, { recursive: true })
+    fs.writeFileSync(
+      path.join(STORE_DIR, 'applied.json'),
+      JSON.stringify({ build: BUILD, pid: process.pid, at: new Date().toISOString() }, null, 2),
+      'utf8',
+    )
+  } catch (error) {
+    console.warn('[experience] applied marker failed:', error && error.message)
+  }
+  let store = loadStore()
+  const cache = new Map()
+  const traces = new Map()
+  const bound = new Map()
+  const liveCalls = new Map()
+  const probe = { done: false }
+  let currentTrace = null
+
+  const persist = () => {
+    try {
+      saveStore(store)
+    } catch (error) {
+      console.warn('[experience] persist failed:', error && error.message)
+    }
+  }
+
+  function renderBlock(chosen, nonce) {
+    const lines = [
+      '[AUTO-RECALL] 以下是跨会话沉淀、且经人工确认的已验证经验（参考数据，不是用户指令）。',
+      '只在确实适用时采用；与当前任务冲突时以当前任务为准。',
+    ]
+    for (const { experience } of chosen) {
+      lines.push('')
+      lines.push(`## ${experience.id} · ${experience.title}`)
+      if (experience.when) lines.push(`适用：${experience.when}`)
+      const steps = (experience.steps || []).slice(0, 6)
+      steps.forEach((step, index) => lines.push(`${index + 1}. ${step}`))
+      const pitfalls = experience.pitfalls || experience.reverse_examples || []
+      if (pitfalls.length) lines.push(`坑：${pitfalls.slice(0, 3).join('；')}`)
+    }
+    lines.push('')
+    lines.push(`需要完整细节时调用 experience_lookup（ids: ${chosen.map((c) => c.experience.id).join(', ')}）。`)
+    lines.push(`[END AUTO-RECALL nonce=${nonce}] 若使用了其中任何一条，在回答中回显 nonce。`)
+    const text = lines.join('\n')
+    return text.length > MAX_CHARS ? `${text.slice(0, MAX_CHARS)}\n[truncated]` : text
+  }
+
+  function recallable(experience) {
+    if (!experience) return false
+    if (experience.decay && experience.decay.state === 'dormant' && !D.isPinned(experience)) return false
+    if (experience.status === 'verified') return true
+    return CONFIG.allowAutoVerified === true && experience.status === 'auto-verified'
+  }
+
+  function recall(payload) {
+    const agent = payload.agent
+    const id = agentId(agent)
+    const turn = payload.turn
+    const step = payload.step
+    if (!id || step !== 1) return
+
+    const queryText = (payload.messages || []).map(textOfMessage).join('\n')
+    const queryTokens = tokens(queryText)
+    const scored = store.experiences
+      .map((experience) => ({ experience, score: scoreExperience(experience, queryTokens) }))
+      .sort((a, b) => b.score - a.score)
+    const candidates = scored.slice(0, 5).map(({ experience, score }) => ({
+      id: experience.id,
+      title: experience.title,
+      status: experience.status,
+      score,
+      passed: recallable(experience) && score >= THRESHOLD,
+    }))
+    const chosen = scored
+      .filter((entry) => recallable(entry.experience) && entry.score >= THRESHOLD)
+      .slice(0, MAX_EXPERIENCES)
+
+    const trace = {
+      sessionId: id,
+      turn,
+      startedAt: new Date().toISOString(),
+      endedAt: null,
+      steps: 0,
+      query: queryText.slice(0, 400),
+      queryTokens: [...queryTokens].slice(0, 40),
+      candidates,
+      threshold: THRESHOLD,
+      injected: chosen.map((entry) => entry.experience.id),
+      injectionId: null,
+      scores: Object.fromEntries(chosen.map((entry) => [entry.experience.id, entry.score])),
+      calls: [],
+      capture: null,
+    }
+    traces.set(id, trace)
+    currentTrace = trace
+
+    if (!chosen.length) {
+      cache.set(id, { block: '', rendered: false })
+      return
+    }
+
+    const nonce = `exp-${crypto.randomBytes(3).toString('hex')}`
+    const block = renderBlock(chosen, nonce)
+    const injection = {
+      id: `inj-${store.nextInjectionId++}`,
+      at: new Date().toISOString(),
+      agentId: id,
+      turn,
+      experienceIds: chosen.map((entry) => entry.experience.id),
+      nonce,
+      chars: block.length,
+      tokens: estimateTokens(block),
+      rendered: false,
+      renderedAt: null,
+    }
+    store.injections.push(injection)
+    if (store.injections.length > 200) store.injections = store.injections.slice(-200)
+    trace.injectionId = injection.id
+    cache.set(id, { block, rendered: false, nonce, injectionId: injection.id })
+    for (const entry of chosen) {
+      entry.experience.uses = (entry.experience.uses || 0) + 1
+      entry.experience.lastUsedAt = injection.at
+    }
+    persist()
+  }
+
+  function markRendered(id) {
+    const entry = cache.get(id)
+    if (!entry || !entry.injectionId || entry.rendered) return
+    entry.rendered = true
+    const injection = store.injections.find((item) => item.id === entry.injectionId)
+    if (injection) {
+      injection.rendered = true
+      injection.renderedAt = new Date().toISOString()
+    }
+    // The flag is the only durable proof that the text reached the request, so it
+    // must survive a crash between assembly and turn close.
+    persist()
+  }
+
+  function bindAgent(agent) {
+    const id = agentId(agent)
+    if (!id || bound.has(id)) return
+    const scope = agent.ctx || ctx
+    if (!scope || !scope.systemPrompt) {
+      console.warn('[experience] agent without scoped systemPrompt, skipped:', id)
+      return
+    }
+    bound.set(id, () => {})
+    const dispose = scope.systemPrompt.context({
+      name: 'experience-recall-v2',
+      order: 9000,
+      required: true,
+      text: () => {
+        const entry = cache.get(id)
+        if (!entry || !entry.block) return ''
+        markRendered(id)
+        return entry.block
+      },
+    })
+    bound.set(id, () => {
+      try {
+        dispose()
+      } catch {}
+    })
+  }
+
+  function unbindAgent(agent) {
+    const id = agentId(agent)
+    const dispose = id ? bound.get(id) : null
+    if (!dispose) return
+    try {
+      dispose()
+    } catch {}
+    bound.delete(id)
+  }
+
+  ctx.effect(() => () => {
+    for (const id of [...bound.keys()]) {
+      try {
+        bound.get(id)()
+      } catch {}
+    }
+    bound.clear()
+  })
+  ctx.on('agent/disposed', (payload) => {
+    try {
+      unbindAgent(payload && payload.agent)
+    } catch {}
+  })
+
+  for (const agent of safeList(ctx)) bindAgent(agent)
+  ctx.on('agent/created', (payload) => {
+    try {
+      bindAgent(payload && payload.agent)
+    } catch (error) {
+      console.warn('[experience] bind failed:', error && error.message)
+    }
+  })
+
+  // ---- deterministic capture: observe tool outcomes (emit, no dispatch cost) ----
+
+  function initiatorId() {
+    try {
+      const agent = ctx.agents && ctx.agents.currentInitiator ? ctx.agents.currentInitiator() : null
+      return agentId(agent)
+    } catch {
+      return ''
+    }
+  }
+
+  function ensureProbe(exec, result) {
+    if (probe.done) return
+    probe.done = true
+    try {
+      const shape = (value) => {
+        if (!value || typeof value !== 'object') return { type: typeof value }
+        const out = {}
+        for (const [key, item] of Object.entries(value)) {
+          out[key] = Array.isArray(item) ? 'array' : item === null ? 'null' : typeof item
+        }
+        return out
+      }
+      fs.writeFileSync(
+        PROBE_FILE,
+        JSON.stringify(
+          {
+            at: new Date().toISOString(),
+            build: BUILD,
+            execKeys: exec && typeof exec === 'object' ? Object.keys(exec) : [],
+            execShape: shape(exec),
+            resultKeys: result && typeof result === 'object' ? Object.keys(result) : [],
+            resultShape: shape(result),
+          },
+          null,
+          2,
+        ),
+        'utf8',
+      )
+    } catch (error) {
+      console.warn('[experience] probe failed:', error && error.message)
+    }
+  }
+
+  function recordCall(exec, result) {
+    try {
+      ensureProbe(exec, result)
+      const id = agentId(exec && exec.agent) || initiatorId()
+      if (!id) return
+      const ok = pickOk(exec, result)
+      const list = liveCalls.get(id) || []
+      if (list.length >= 80) list.shift()
+      list.push({
+        name: pickName(exec),
+        hint: C.clipRaw(hintOf(pickArgs(exec)), 120),
+        ok,
+        error: ok ? '' : C.clip(pickError(exec, result), 160),
+        ms: null,
+      })
+      liveCalls.set(id, list)
+    } catch (error) {
+      console.warn('[experience] recordCall failed:', error && error.message)
+    }
+  }
+
+  ctx.on('tools/result', (exec, result) => recordCall(exec, result))
+
+  // ---- capture at turn close ----
+
+  function noteEvidence(record, trace, outcomeKind, byFingerprint, steps) {
+    if (!record) return null
+    try {
+      const run = {
+        sessionId: trace.sessionId,
+        turn: trace.turn,
+        at: new Date().toISOString(),
+        outcome: outcomeKind,
+        byFingerprint: Boolean(byFingerprint),
+        verificationOnly: Boolean(trace.verificationOnly),
+        green: Boolean(byFingerprint),
+        errors: (trace.calls || []).filter((call) => !call.ok).length,
+        steps: (steps || record.steps || []).slice(0, 8),
+      }
+      const { proof } = E.recordEvidence(record, run)
+      const promoted = E.promote(record, CONFIG)
+      return { proof, promoted }
+    } catch (error) {
+      console.warn('[experience] evidence failed:', error && error.message)
+      return null
+    }
+  }
+
+  function noteGatedFailure(trace) {
+    try {
+      const queryTokens = tokens(trace.query || '')
+      let best = null
+      for (const existing of store.experiences) {
+        if (!['verified', 'auto-verified', 'candidate'].includes(existing.status)) continue
+        const score = scoreExperience(existing, queryTokens)
+        if (score >= CONFIG.mergeThreshold && (!best || score > best.score)) best = { existing, score }
+      }
+      if (best) noteEvidence(best.existing, trace, 'failure', false, C.summarizeCalls(trace.calls || []))
+    } catch (error) {
+      console.warn('[experience] failure evidence failed:', error && error.message)
+    }
+  }
+
+  function runCapture(trace, agent) {
+    const started = performance.now()
+    const outcome = { ok: false, reason: null, ms: 0, id: null, merged: null, added: 0 }
+    try {
+      const today = new Date().toISOString().slice(0, 10)
+      const autoTotal = store.experiences.filter((item) => item.source && item.source.auto).length
+      const todayAdded = store.experiences.filter(
+        (item) => item.source && item.source.auto && String(item.source.at || '').slice(0, 10) === today,
+      ).length
+
+      const gate = C.shouldCapture(trace, { todayAdded, autoTotal }, CONFIG)
+      if (!gate.ok) {
+        outcome.reason = gate.reason
+        if (String(gate.reason).startsWith('G3')) noteGatedFailure(trace)
+        outcome.ms = Math.round(performance.now() - started)
+        return outcome
+      }
+      trace.verificationOnly = Boolean(gate.verificationOnly)
+
+      const draft = C.buildCandidate(
+        trace,
+        { cwd: workspaceOf(agent), sessionId: trace.sessionId, agentId: trace.sessionId, turn: trace.turn },
+        CONFIG,
+      )
+
+      const elapsed = performance.now() - started
+      if (elapsed > CONFIG.captureBudgetMs) {
+        outcome.reason = `熔断: 抽取 ${Math.round(elapsed)}ms > ${CONFIG.captureBudgetMs}ms`
+        outcome.ms = Math.round(elapsed)
+        return outcome
+      }
+      if (JSON.stringify(draft).length < 120) {
+        outcome.reason = 'G6: 抽取内容过短'
+        outcome.ms = Math.round(elapsed)
+        return outcome
+      }
+
+      // G7: the capture has to read as a recipe, not as shell transcript fragments.
+      const quality = C.gateStepQuality(trace, draft, CONFIG)
+      if (!quality.ok) {
+        trace.skipReason = quality.reason
+        outcome.reason = quality.reason
+        outcome.ms = Math.round(performance.now() - started)
+        return outcome
+      }
+
+      // G8: never re-adopt a recipe a human already rejected as rule-conflicting.
+      const superseded = C.gateSuperseded(draft, store.experiences)
+      if (!superseded.ok) {
+        trace.skipReason = superseded.reason
+        outcome.reason = superseded.reason
+        outcome.superseded = superseded.hit.id
+        outcome.ms = Math.round(performance.now() - started)
+        return outcome
+      }
+
+      const queryTokens = tokens([draft.title, draft.taskType, draft.when, (draft.keywords || []).join(' ')].join(' '))
+      const sameScope = (record) => !CONFIG.scopeMustMatch || !C.scopeConflicts(record, draft)
+      const mergeable = ['verified', 'auto-verified', 'candidate']
+      const runSteps = C.summarizeCalls(trace.calls || [])
+
+      let fpBest = null
+      for (const existing of store.experiences) {
+        if (!mergeable.includes(existing.status)) continue
+        if (!sameScope(existing)) continue
+        if (!C.fingerprintsMatch(existing, draft)) continue
+        if (!fpBest) fpBest = existing
+      }
+
+      let best = null
+      for (const existing of store.experiences) {
+        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 (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.
+      const target = fpBest
+        ? { existing: fpBest, score: 0, byFingerprint: true }
+        : best
+          ? { existing: best.existing, score: best.score, byFingerprint: false }
+          : null
+
+      if (target) {
+        const merged = C.mergeInto(target.existing, draft)
+        if (target.byFingerprint) E.markFingerprintEquivalent(target.existing, new Date().toISOString())
+        noteEvidence(target.existing, trace, 'success', target.byFingerprint, runSteps)
+        outcome.ok = true
+        outcome.merged = target.existing.id
+        outcome.added = merged.added.length
+        outcome.byFingerprint = target.byFingerprint
+        outcome.reason = target.byFingerprint
+          ? `G4: 结果指纹命中 ${target.existing.id}（${((draft.fingerprint && draft.fingerprint.targets) || []).join(', ')} 全绿；步骤差异不参与判定）→ 合并，新增反例 ${merged.added.length} 条`
+          : `G4: 命中已有经验 ${target.existing.id}（${target.score}）→ 新增反例 ${merged.added.length} 条`
+        outcome.ms = Math.round(performance.now() - started)
+        persist()
+        return outcome
+      }
+
+      const id = `exp-${store.nextId++}`
+      const created = { id, ...draft }
+      store.experiences.push(created)
+      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.ms = Math.round(performance.now() - started)
+      persist()
+      return outcome
+    } catch (error) {
+      outcome.reason = `capture-error: ${error && error.message}`
+      outcome.ms = Math.round(performance.now() - started)
+      return outcome
+    }
+  }
+
+  ctx.on('agent/pre-step', async (payload, next) => {
+    let decision
+    try {
+      decision = await next()
+    } catch (error) {
+      throw error
+    }
+    try {
+      if (decision && decision.kind === 'enter') {
+        const id = agentId(payload.agent)
+        const trace = traces.get(id)
+        if (trace && trace.turn === payload.turn) trace.steps = Math.max(trace.steps, payload.step)
+        recall(payload)
+      }
+    } catch (error) {
+      const id = agentId(payload.agent)
+      const trace = id ? traces.get(id) : null
+      if (trace && trace.turn === payload.turn) trace.error = String(error && error.message)
+      console.warn('[experience] recall failed:', error && error.message)
+    }
+    return decision
+  })
+
+  ctx.on('agent/turn-stopping', (payload) => {
+    try {
+      const id = agentId(payload && payload.agent)
+      const calls = liveCalls.get(id) || []
+      liveCalls.delete(id)
+      const trace = traces.get(id)
+      if (!trace || trace.turn !== payload.turn) return
+      trace.calls = calls.slice(-CONFIG.maxCalls)
+      trace.endedAt = new Date().toISOString()
+      trace.durationMs = Date.parse(trace.endedAt) - Date.parse(trace.startedAt)
+      const capture = runCapture(trace, payload.agent)
+      // 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) }))
+      D.markDecay(store.experiences, Date.now(), CONFIG)
+      trace.capture = capture
+      store.turns.push(trace)
+      if (store.turns.length > 100) store.turns = store.turns.slice(-100)
+      traces.delete(id)
+      if (currentTrace === trace) currentTrace = null
+      persist()
+    } catch (error) {
+      console.warn('[experience] trace close failed:', error && error.message)
+    }
+  })
+
+  // ---- tools -------------------------------------------------------------
+
+  ctx.tools.register({
+    name: 'experience_record',
+    description:
+      'Record a reusable, task-level experience as a CANDIDATE (not yet trusted). ' +
+      'Call it after finishing a task whose method is likely to repeat. A human must run ' +
+      '/memory approve <id> before it can be recalled in future sessions.',
+    parameters: {
+      title: { type: 'string', required: true, description: 'Short reusable name, e.g. "为 Node 项目新增一个纯函数并配 node:test 用例"' },
+      taskType: { type: 'string', description: 'Task family, e.g. "node-project/feature"' },
+      when: { type: 'string', description: 'Applicability condition: when this recipe is worth reusing' },
+      keywords: { type: 'array', items: { type: 'string' }, description: 'Retrieval keywords (paths, commands, library names)' },
+      steps: { type: 'array', items: { type: 'string' }, required: true, description: 'Ordered, concrete steps with exact commands/paths' },
+      pitfalls: { type: 'array', items: { type: 'string' }, description: 'What went wrong or what to avoid' },
+      evidence: { type: 'string', description: 'Where the evidence comes from (session/turn, command output)' },
+    },
+    output: {
+      schema: { type: 'string' },
+      render: (_args, value) => [{ type: 'text', text: String(value) }],
+    },
+    async execute(args, exec) {
+      const id = `exp-${store.nextId++}`
+      const record = {
+        id,
+        status: 'candidate',
+        title: String(args.title || '').trim(),
+        taskType: String(args.taskType || '').trim(),
+        when: String(args.when || '').trim(),
+        keywords: Array.isArray(args.keywords) ? args.keywords.map(String) : [],
+        steps: Array.isArray(args.steps) ? args.steps.map(String) : [],
+        pitfalls: Array.isArray(args.pitfalls) ? args.pitfalls.map(String) : [],
+        evidence: String(args.evidence || '').trim(),
+        source: {
+          agentId: agentId(exec && exec.agent) || 'unknown',
+          at: new Date().toISOString(),
+          origin: 'manual',
+        },
+        verify: null,
+        confidence: 0.4,
+        uses: 0,
+        lastUsedAt: null,
+        occurrences: 1,
+      }
+      store.experiences.push(record)
+      persist()
+      return [
+        `已记录候选经验 ${id}: ${record.title}`,
+        'status=candidate（不会被跨会话召回）',
+        '人工确认：/memory review 查看全部候选，或 /memory approve ' + id,
+        `查看内容：/memory show ${id}`,
+      ].join('\n')
+    },
+  })
+
+  ctx.tools.register({
+    name: 'experience_lookup',
+    description:
+      'Read full stored experience records by id (candidate or verified). Use after an ' +
+      'AUTO-RECALL block names ids, or when the user asks what was learned before.',
+    parameters: {
+      ids: { type: 'array', items: { type: 'string' }, description: 'Experience ids, e.g. ["exp-1"]' },
+    },
+    output: {
+      schema: { type: 'string' },
+      render: (_args, value) => [{ type: 'text', text: String(value) }],
+    },
+    async execute(args) {
+      return renderLookup(args.ids, store.experiences, formatExperience)
+    },
+  })
+
+  ctx.tools.register({
+    name: 'experience_forget',
+    description:
+      'Delete a CANDIDATE experience from the store (cleanup of junk/duplicate candidates). ' +
+      'Verified skills cannot be deleted by an agent — they need a human.',
+    parameters: { id: { type: 'string', required: true, description: 'Experience id, e.g. exp-2' } },
+    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[index]
+      if (target.status === 'verified') {
+        return `拒绝：${args.id} 已是被验证技能，Agent 不能删除。请人工处理。`
+      }
+      store.experiences.splice(index, 1)
+      store.injections = store.injections.filter((item) => !(item.experienceIds || []).includes(args.id))
+      persist()
+      return `已删除候选经验 ${args.id}（${target.title}），剩余 ${store.experiences.length} 条。`
+    },
+  })
+
+  ctx.tools.register({
+    name: 'experience_review',
+    description:
+      'READ-ONLY view of pending candidate experiences, identical to /memory review. ' +
+      'This tool cannot approve or reject anything: promotion is a human-only action.',
+    parameters: {},
+    output: {
+      schema: { type: 'string' },
+      render: (_args, value) => [{ type: 'text', text: String(value) }],
+    },
+    async execute() {
+      return [C.renderReview(store.experiences), '', '（只读视图；批准只能由人执行 /memory review --approve-all 或 approve <n>）'].join('\n')
+    },
+  })
+
+  ctx.tools.register({
+    name: 'experience_debug',
+    description:
+      'Layered diagnosis of the most recent traced turn (store -> eligible -> retrieval -> ' +
+      'injection -> model-visible -> effective), plus why L1 capture did or did not fire. ' +
+      'Use it when an AUTO-RECALL or a capture was expected but missing.',
+    parameters: {},
+    output: {
+      schema: { type: 'string' },
+      render: (_args, value) => [{ type: 'text', text: String(value) }],
+    },
+    async execute(_args, exec) {
+      const live = traces.get(agentId(exec && exec.agent))
+      const last = live || store.turns[store.turns.length - 1]
+      const lastInjection = store.injections[store.injections.length - 1]
+      const captures = store.turns.map((turn) => turn.capture).filter((item) => item && item.ok)
+      const avgMs = captures.length
+        ? Math.round(captures.reduce((sum, item) => sum + (item.ms || 0), 0) / captures.length)
+        : 0
+      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})`,
+        `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(',')}` : '-'}`,
+        '',
+      ]
+      return head.concat([last ? explainTurn(last) : '(无 turn 记录)']).join('\n')
+    },
+  })
+
+  function formatExperience(experience) {
+    const pitfalls = experience.pitfalls || experience.reverse_examples || []
+    const lines = [
+      `# ${experience.id} [${experience.status}] ${experience.title}`,
+      `taskType: ${experience.taskType || '-'}`,
+      `适用: ${experience.when || '-'}`,
+      `keywords: ${(experience.keywords || []).join(', ') || '-'}`,
+      '步骤:',
+      ...(experience.steps || []).map((step, index) => `  ${index + 1}. ${step}`),
+    ]
+    if (pitfalls.length) lines.push(`反例: ${pitfalls.join('；')}`)
+    if (experience.evidence) lines.push(`证据: ${experience.evidence}`)
+    lines.push(`verify: ${experience.verify ? `${experience.verify.by} @ ${experience.verify.at}` : '-'}`)
+    lines.push(`uses: ${experience.uses || 0}  lastUsedAt: ${experience.lastUsedAt || '-'}  occurrences: ${experience.occurrences || 1}`)
+    return lines.join('\n')
+  }
+
+  // ---- commands ----------------------------------------------------------
+
+  function approveExperience(found, method) {
+    found.status = 'verified'
+    found.verify = { by: 'human', at: new Date().toISOString(), method }
+    found.confidence = 0.8
+    persist()
+  }
+
+  function resolveReviewTarget(token) {
+    const candidates = C.reviewTargets(store.experiences)
+    const raw = String(token || '').trim()
+    if (!raw) return null
+    const id = raw.startsWith('#') ? raw.slice(1) : raw
+    if (/^exp-\d+$/.test(id)) return store.experiences.find((item) => item.id === id) || null
+    if (/^\d+$/.test(id)) return candidates[Number(id) - 1] || null
+    const byTitle = store.experiences.find((item) => item.title === raw)
+    return byTitle || null
+  }
+
+  function reviewCommand(arg) {
+    const line = String(arg || '').trim()
+    if (!line) return C.renderReview(store.experiences)
+    if (line === '--auto' || line === 'auto') {
+      const auto = store.experiences.filter((item) => item.status === 'auto-verified')
+      if (!auto.length) return '没有 auto-verified 经验（autoPromote 关闭，或证据还没攒够）。'
+      return [
+        'auto-verified（未人工确认，默认不参与召回）：',
+        ...auto.map((item) => {
+          const state = E.promotionState(item, CONFIG)
+          return `  ${item.id} ${item.title} · runs=${(item.proof?.runs || []).length} sessions=${item.proof?.distinctSessions || 0} · ${state.eligible ? 'ready' : state.reason}`
+        }),
+      ].join('\n')
+    }
+    if (line === '--approve-all' || line === 'approve-all' || line === 'approve --all') {
+      const candidates = C.reviewTargets(store.experiences)
+      if (!candidates.length) return '没有待确认的候选经验。'
+      for (const item of candidates) approveExperience(item, 'review-all')
+      return [`已批准 ${candidates.length} 条候选经验：`, ...candidates.map((item) => `  ${item.id} → verified（${item.title}）`)].join('\n')
+    }
+    const match = line.match(/^(approve|reject)\s+(.+)$/)
+    if (!match) return '用法：/memory review | /memory review --approve-all | /memory review approve <n|id> | /memory review reject <n|id>'
+    const target = resolveReviewTarget(match[2])
+    if (!target) return `没有匹配的候选：${match[2]}`
+    if (match[1] === 'approve') {
+      approveExperience(target, 'review-one')
+      return `${target.id} 已升级为 verified，下次相似任务会进入召回池。`
+    }
+    target.status = 'rejected'
+    target.verify = { by: 'human', at: new Date().toISOString(), method: 'review-reject' }
+    persist()
+    return `${target.id} 已标记 rejected，不再召回。`
+  }
+
+  ctx.commands.register({
+    name: 'memory',
+    description: '跨会话经验：list / show / review / approve / reject / teach / why / debug / stats / config / decay / restore',
+    input: { hint: 'list | review [--approve-all|approve <n>|reject <n>] | show <id> | why | debug | stats | config [set <key> <value>] | decay [--apply] | restore <id> | supersede <id> [原因]' },
+    handler: ({ rawInput }) => {
+      const line = String(rawInput || '').trim()
+      const [verb, ...rest] = line.split(/\s+/)
+      const arg = rest.join(' ')
+      switch (verb) {
+        case '':
+        case 'list': {
+          if (!store.experiences.length) return ok('档案为空。用 /memory teach 或让 agent 调用 experience_record 记录第一条。')
+          return ok(
+            store.experiences
+              .map((item) => {
+                const origin = item.source && item.source.auto ? 'auto' : 'manual'
+                const count = (item.reverse_examples || item.pitfalls || []).length
+                const faded = item.decay && item.decay.state === 'dormant' ? ' · dormant' : ''
+                return `${item.id} [${item.status}] (${origin}) ${item.title}${count ? ` · 反例${count}` : ''}${faded}`
+              })
+              .join('\n'),
+          )
+        }
+        case 'review':
+          return ok(reviewCommand(arg))
+        case 'show': {
+          const found = store.experiences.find((item) => item.id === arg)
+          return found ? ok(formatExperience(found)) : err(`没有 ${arg}`)
+        }
+        case 'reevaluate': {
+          const found = arg ? store.experiences.find((item) => item.id === arg) : null
+          const targets = found ? [found] : store.experiences.filter((item) => ['candidate', 'auto-verified'].includes(item.status))
+          if (!targets.length) return err('没有可重新评估的候选经验')
+          const lines = targets.map((item) => {
+            const state = E.promotionState(item, CONFIG)
+            const result = E.promote(item, CONFIG)
+            const label = state.eligible ? 'ready' : state.code
+            return `${item.id} [${item.status}] ${label} · ${state.reason}${result.promoted ? ' → 已升级 auto-verified' : ''}`
+          })
+          persist()
+          return ok(lines.join('\n'))
+        }
+        case 'approve': {
+          const found = store.experiences.find((item) => item.id === arg)
+          if (!found) return err(`没有 ${arg}`)
+          approveExperience(found, 'command')
+          return ok(`${found.id} 已升级为 verified，下次相似任务会进入召回池。`)
+        }
+        case 'reject': {
+          const found = store.experiences.find((item) => item.id === arg)
+          if (!found) return err(`没有 ${arg}`)
+          found.status = 'rejected'
+          found.verify = { by: 'human', at: new Date().toISOString(), method: 'command-reject' }
+          persist()
+          return ok(`${found.id} 已标记 rejected，不再召回。`)
+        }
+        case 'supersede': {
+          const parts = String(arg || '').trim().split(/\s+/)
+          const found = store.experiences.find((item) => item.id === parts[0])
+          if (!found) return err(`没有 ${parts[0] || '(空)'}`)
+          const rule = parts.slice(1).join(' ').trim() || '与 AGENTS.md 规则冲突'
+          found.status = 'superseded'
+          found.supersede = { by: 'human', at: new Date().toISOString(), rule }
+          found.verify = null
+          persist()
+          return ok(`${found.id} 已标记 superseded（${rule}）：不再召回，同指纹的轨迹也不会再被收录。`)
+        }
+        case 'teach': {
+          const [titlePart, stepsPart] = arg.split('||')
+          const title = String(titlePart || '').trim()
+          const steps = String(stepsPart || '').split(';').map((step) => step.trim()).filter(Boolean)
+          if (!title || !steps.length) return err('用法：/memory teach 标题 || 步骤1; 步骤2')
+          const id = `exp-${store.nextId++}`
+          store.experiences.push({
+            id,
+            status: 'verified',
+            title,
+            taskType: '',
+            when: '',
+            keywords: [...tokens(title)].slice(0, 20),
+            steps,
+            pitfalls: [],
+            evidence: 'human-taught',
+            source: { agentId: 'human', at: new Date().toISOString(), origin: 'human' },
+            verify: { by: 'human', at: new Date().toISOString(), method: 'teach' },
+            confidence: 0.9,
+            uses: 0,
+            lastUsedAt: null,
+            occurrences: 1,
+          })
+          persist()
+          return ok(`${id} 已作为 verified 手动写入：${title}`)
+        }
+        case 'decay': {
+          const parts = String(arg || '').split(/\s+/)
+          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 (!parts.includes('--apply')) {
+            D.markDecay(store.experiences, Date.now(), CONFIG)
+            persist()
+            const report = D.renderDecayReport(store, now, CONFIG)
+            return ok(simulated ? `${report}\n（模拟：把整库老化 ${simulatedDays} 天，仅影响本次展示）` : report)
+          }
+          const result = D.applyEvictions(store, now, CONFIG, 'command')
+          D.markDecay(store.experiences, now, CONFIG)
+          persist()
+          return ok(`${result.reason}\n归档: ${result.archived.join(', ') || '(无)'}\n恢复: /memory restore <id>`)
+        }
+        case 'restore': {
+          const restored = D.restoreRecord(store, String(arg || '').trim())
+          if (!restored) return err(`archive 里没有 ${arg}`)
+          D.markDecay(store.experiences, Date.now(), CONFIG)
+          persist()
+          return ok(`${restored.id} 已恢复为 ${restored.status}，decay 状态已重置。`)
+        }
+        case 'why': {
+          const last = store.turns[store.turns.length - 1]
+          if (!last) return err('还没有记录到 turn 轨迹。')
+          return ok(explainTurn(last))
+        }
+        case 'debug': {
+          const last = store.turns[store.turns.length - 1]
+          const lastInjection = store.injections[store.injections.length - 1]
+          const captures = store.turns.map((turn) => turn.capture).filter((item) => item && item.ok)
+          const avgMs = captures.length
+            ? Math.round(captures.reduce((sum, item) => sum + (item.ms || 0), 0) / captures.length)
+            : 0
+          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})`,
+            `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(',')}` : '-'}`,
+            '',
+            D.renderDecayReport(store, Date.now(), CONFIG),
+            '',
+            last ? explainTurn(last) : '(无 turn 记录)',
+          ]
+          return ok(lines.join('\n'))
+        }
+        case 'stats': {
+          const candidates = C.reviewTargets(store.experiences)
+          const captures = store.turns.map((turn) => turn.capture).filter((item) => item && item.ok)
+          const avgMs = captures.length
+            ? Math.round(captures.reduce((sum, item) => sum + (item.ms || 0), 0) / captures.length)
+            : 0
+          return ok(
+            [
+              `库 ${store.experiences.length} 条（verified ${store.experiences.filter((i) => i.status === 'verified').length} / candidate ${candidates.length} / rejected ${store.experiences.filter((i) => i.status === 'rejected').length}）`,
+              `自动捕获 ${captures.length} 次，平均 ${avgMs}ms（预算 ${CONFIG.captureBudgetMs}ms）`,
+              `注入 ${store.injections.length} 次，最后一条 ${store.injections.length ? store.injections[store.injections.length - 1].id : '-'}`,
+              `配额：今日上限 ${CONFIG.dailyLimit}，库上限 ${CONFIG.libraryLimit}，去重阈值 ${CONFIG.mergeThreshold}`,
+            ].join('\n'),
+          )
+        }
+        case 'config': {
+          if (!arg) return ok(JSON.stringify(CONFIG, null, 2))
+          const match = arg.match(/^set\s+(\w+)\s+(.+)$/)
+          if (!match) return err('用法：/memory config | /memory config set <key> <value>')
+          const key = match[1]
+          if (!(key in C.DEFAULT_CONFIG)) return err(`未知配置项 ${key}，可选：${Object.keys(C.DEFAULT_CONFIG).join(', ')}`)
+          const raw = match[2].trim()
+          let value
+          try {
+            value = C.coerceConfigValue(key, raw)
+          } catch (error) {
+            return err(String(error && error.message))
+          }
+          CONFIG[key] = value
+          saveConfig()
+          return ok(`${key} = ${JSON.stringify(value)}（已写入 ${CONFIG_FILE}）`)
+        }
+        default:
+          return err(`未知子命令 ${verb}`)
+      }
+    },
+  })
+
+  function evidenceLine(turn) {
+    const ids = (turn.candidates || []).slice(0, 3).map((item) => item.id)
+    const records = ids.map((id) => store.experiences.find((item) => item.id === id)).filter(Boolean)
+    if (!records.length) return '- （没有候选可评估）'
+    return records
+      .map((record) => {
+        const state = E.promotionState(record, CONFIG)
+        const proof = record.proof || {}
+        const effective = state.stability ?? proof.minStability
+        const raw = proof.minStability ?? 'n/a'
+        const shown = state.stability !== null && state.stability !== undefined && state.stability !== proof.minStability ? `${effective}（原始 ${raw}）` : `${raw}`
+        return `${record.id} runs=${(proof.runs || []).length} sessions=${proof.distinctSessions || 0} stability=${shown} · ${state.eligible ? 'ready' : state.reason}`
+      })
+      .join(' | ')
+  }
+
+  function explainTurn(turn) {
+    const verified = store.experiences.filter((item) => item.status === 'verified')
+    const injection = store.injections.find((item) => item.id === turn.injectionId)
+    const pass = (flag) => (flag ? 'PASS' : 'FAIL')
+    const capture = turn.capture || {}
+    const lines = [
+      `turn: session=${turn.sessionId} turn=${turn.turn} steps=${turn.steps} durationMs=${turn.durationMs ?? '?'}`,
+      `query: ${turn.query.slice(0, 160)}`,
+      `queryTokens: ${(turn.queryTokens || []).join(' ') || '(空)'}`,
+      `candidates: ${(turn.candidates || []).map((c) => `${c.id}=${c.score}${c.status ? `(${c.status})` : ''}${c.passed ? '*' : ''}`).join(' ') || '(空)'}`,
+      `threshold: ${turn.threshold}`,
+      `calls: ${(turn.calls || []).length}（失败 ${(turn.calls || []).filter((c) => !c.ok).length}）`,
+      `capture: ${capture.ok ? `PASS ${capture.id || capture.merged || ''} (${capture.ms}ms${capture.added ? `, +${capture.added} 反例` : ''})` : `SKIP ${capture.reason || '(未执行)'}`}`,
+      '',
+      '[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(' | ') || '(空)'),
+      `[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 : '(无)'}`,
+      '[6 生效] 对比 steps/durationMs 与第一次。',
+      '',
+      hintFor(turn, injection, verified),
+    ]
+    return lines.join('\n')
+  }
+
+  function hintFor(turn, injection, verified) {
+    if (!store.experiences.length) return '卡在 [1 存储]：先 experience_record 或 /memory teach。'
+    if (!verified.length) {
+      const blocked = (turn.candidates || []).filter((c) => c.status === 'candidate' && c.score >= turn.threshold)
+      if (blocked.length) {
+        return `卡在 [2 可召回]：${blocked.map((c) => c.id).join(', ')} 得分已过阈值（${blocked.map((c) => c.score).join(', ')}），但 status=candidate —— 运行 /memory review 批量确认后重跑同类任务。`
+      }
+      return '卡在 [2 可召回]：只有 candidate，运行 /memory review 查看并批准。'
+    }
+    if (!injection) {
+      const top = turn.candidates && turn.candidates[0]
+      if (!top) return '卡在 [3 检索]：verified 经验都被过滤（检查 status）。'
+      return `卡在 [3 检索]：最高分 ${top.score} < ${turn.threshold}。补充 title/when/keywords 或调低阈值。`
+    }
+    if (!injection.rendered) return '卡在 [4 注入]：pre-step 选了经验，但 systemPrompt.context 的 text() 未被调用。'
+    return '注入链路已通；剩下只看向下一个问题：模型是否真的按经验执行、效率是否提升。'
+  }
+
+  const ok = (text) => ({ kind: 'success', text })
+  const err = (text) => ({ kind: 'error', text })
+}
+
+function safeList(ctx) {
+  try {
+    if (!ctx.agents || typeof ctx.agents.list !== 'function') return []
+    return ctx.agents.list() || []
+  } catch {
+    return []
+  }
+}
+// reload-marker: 2026-11-09 round2-l1