@a9i5k4/dsh-auto-memory 3.0.1 → 3.1.1

package/lib/config-io.js

@@ -27,12 +27,34 @@
  *   - CRLF、无 BOM。
  */
 import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs'
-import { writeFile } from 'node:fs/promises'
+import { rename, writeFile } from 'node:fs/promises'
+import { setTimeout as sleepDelayPre } from 'node:timers/promises'
 import path from 'node:path'
 
 /** 临时文件后缀。与既有 hub 落盘的 `.tmp` 同族，便于排查时一眼认出。 */
 export const ATOMIC_TMP_SUFFIX_V1 = '.tmp'
 
+/**
+ * ★2026-09-22（并发写修复）：tmp 路径的**唯一段** = pid + 进程内自增序号。
+ *
+ * 病症：tmp 名原先**只由目标路径决定**（`file + '.tmp'`）⇒ 对同一目标并发保存时，
+ * 先完成者把 tmp 改名走，后到者的 rename 找不到源文件而抛 **ENOENT**（非瞬时错误、
+ * 按纪律不得重试）⇒ 后一次保存静默失败（只回 `{ok:false}`，界面看起来"改了没生效"）。
+ * 实测复现：对同一目标并发 5 次 `writeTextAtomicPre`，部分调用返回
+ * `{ok:false, error:'ENOENT … rename … .tmp -> …'}`（见 `tests/smoke/smoke-test-p3-batchb-guards-pre.mjs` P3B-2d）。
+ *
+ * 处方：每次调用生成一个独立的 tmp 名 —— 同进程并发各写各的，跨进程并发靠 pid 区分；
+ * 最后一次 rename 胜出，**原子性不变量不变**（目标任意时刻仍是旧完整版或新完整版）。
+ *
+ * 边界：仍落在**同目录**且保持 `.tmp` 前缀（`rename` 必须同文件系统）；失败路径照旧
+ * `rmSync` 清理。唯一代价是**进程崩溃**时会在目标目录留下一个 `.tmp-<pid>-<n>`
+ * （可识别、可手工清理；不自动扫描删除，避免误删他人正在写的 tmp）。
+ */
+let _tmpSeqPre = 0
+function tmpUniqueSuffixPre() {
+  return '-' + process.pid + '-' + (++_tmpSeqPre)
+}
+
 /** 损坏留存的默认后缀前缀。 */
 export const CORRUPT_QUARANTINE_PREFIX_V1 = '.corrupt-'
 
@@ -70,7 +92,7 @@ export function quarantineFilePreSync(file, opts = {}) {
  * @returns {{ok: boolean, path?: string, error?: string}} 结构化结果（fail-soft，不抛）。
  */
 export function writeTextAtomicPreSync(file, text) {
-  const tmp = file + ATOMIC_TMP_SUFFIX_V1
+  const tmp = file + ATOMIC_TMP_SUFFIX_V1 + tmpUniqueSuffixPre()
   try {
     mkdirSync(path.dirname(file), { recursive: true })
     writeFileSync(tmp, String(text), 'utf8')
@@ -83,18 +105,49 @@ export function writeTextAtomicPreSync(file, text) {
   }
 }
 
+/**
+ * **有界退避 rename**（★P3-12，2026-09-22）。
+ *
+ * 病症：异步原子写原先走裸 `renameSync` —— Windows 上目标文件被别的进程持有句柄时会抛
+ * EPERM/EACCES/EBUSY，于是**整次设置保存失败**（用户侧表现为"改了设置没生效"）。
+ * 处方：仅对这三个**瞬时**错误码退避重试；首项延迟为 0 ⇒ **正常路径零延迟变化**。
+ *
+ * ⚠️ **为什么不 import `fs-retry.js`**：本模块的**零运行时依赖纪律**（见文件头）
+ * 被 `tests/smoke/smoke-test-t8-configio-pre.mjs` 的 T8c-6 钉死 —— 配置 I/O 层不得因为
+ * 任何兄弟模块的加载期故障而失效。故此处**内联**同一套退避刻度（只用 node: 内置），
+ * 语义与 `fs-retry.js` 的 `retryRename` 保持一致。
+ */
+const RENAME_RETRY_DELAYS_V1 = Object.freeze([0, 50, 150, 400, 1000])
+const TRANSIENT_RENAME_CODES_V1 = new Set(['EPERM', 'EACCES', 'EBUSY'])
+async function renameBoundedRetryPre(from, to) {
+  const last = RENAME_RETRY_DELAYS_V1.length - 1
+  for (let attempt = 0; attempt <= last; attempt++) {
+    const wait = RENAME_RETRY_DELAYS_V1[attempt]
+    if (wait) await sleepDelayPre(wait)
+    try {
+      await rename(from, to)
+      return
+    } catch (e) {
+      const transient = TRANSIENT_RENAME_CODES_V1.has(e && e.code)
+      if (!transient || attempt === last) throw e
+    }
+  }
+}
+
 /**
  * **异步原子写**：tmp → rename。语义与同步版一致。
  *
- * 只把**可能较大**的正文写入交给异步 IO；rename 本身极快，保持同步调用。
- * 这样与既有 `persistConfigPre` 的异步口径对齐，不引入额外的 await 链。
+ * 只把**可能较大**的正文写入交给异步 IO。
+ *
+ * ★P3-12（2026-09-22）：rename 走 `renameBoundedRetryPre`（有界退避；首项 0 ⇒ 正常路径零延迟变化）。
+ * 同步版 `writeTextAtomicPreSync` 的契约是同步，保持 `renameSync` 不动。
  */
 export async function writeTextAtomicPre(file, text) {
-  const tmp = file + ATOMIC_TMP_SUFFIX_V1
+  const tmp = file + ATOMIC_TMP_SUFFIX_V1 + tmpUniqueSuffixPre()
   try {
     mkdirSync(path.dirname(file), { recursive: true })
     await writeFile(tmp, String(text), 'utf8')
-    renameSync(tmp, file)
+    await renameBoundedRetryPre(tmp, file)
     return { ok: true, path: file }
   } catch (e) {
     try { rmSync(tmp, { force: true }) } catch (_) {}

package/lib/context-host.js

@@ -28,6 +28,7 @@ import { createPythonContextSinkPre } from './context-sink-python.js'
 import { buildQueryPlan, lexicalSearch, GATE_POLICY_VERSION, LEXICAL_POLICY_VERSION } from './shadow-retrieval.js'
 import { fuseD6Pre } from './semantic-js.js'
 import { buildSourceCatalog, loadCorpusSnapshot, CorpusRegistry, canonicalize } from './m4-corpus.js'
+import { resolveProcedureInjectEnabledPre } from './procedure-switch.js'
 
 const MAX_DROPS_RING = 64
 /** 同一 drop 原因的日志限流窗口(ms):窗口内只写首条,其余计数。防会话回放刷屏(2026-09-10)。 */
@@ -163,7 +164,11 @@ export function createContextHost(opts = {}) {
     return bridge
   }
   function storeFor() {
-    if (!store) store = new EvidenceEventStore({ root: path.join(dshHome(), 'memory', 'evidence') })
+    if (!store) store = new EvidenceEventStore({
+      root: path.join(dshHome(), 'memory', 'evidence'),
+      // ★P3-9（组2，2026-09-22）：注入统一节流诊断通道；不注入时 store 内回落 console.error。
+      onDiag: (key, msg) => { try { diagCtx(msg) } catch (_) {} },
+    })
     return store
   }
   function evidenceRootExists() {
@@ -534,7 +539,12 @@ export function createContextHost(opts = {}) {
                 // 集合不变则缓存命中);不可用回退词法 2-gram。阈值 0.6(e5 相关内容带)。单 offer 出口。
                 try {
                   const hub = engine._memoryHub
-                  const skillEnabled = engine.config.memoryHubEnabled === true && engine.config.procedurePromotionEnabled !== false
+                  // B-2：旧键 procedurePromotionEnabled 是**语义错配的兼容别名**——它的键名与界面文案写的是
+                  // 「技能固化与晋升」，但它实际控制的是「已激活的技能是否随本轮上下文注入」这道总闸，
+                  // 与晋升流程本身无关。改由接口契约模块 lib/procedure-switch.js 统一解析：
+                  // 新键 procedureInjectEnabled 优先，缺省回退旧键，两键都缺省按开启处理；
+                  // 老用户显式关掉过总闸的，行为不翻面。此处只替换开关解析口径，不新增任何前置条件。
+                  const skillEnabled = engine.config.memoryHubEnabled === true && resolveProcedureInjectEnabledPre(engine.config)
                   if (hub && skillEnabled && hub.stores && hub.stores.procedures) {
                     const actives = hub.stores.procedures.activeProcedures()
                     let hit = null
@@ -813,6 +823,11 @@ export function createContextHost(opts = {}) {
     const st = states.get(runtime)
     if (st) st.disposed = true
     states.delete(runtime)
+    // ★P3-3(a)（2026-09-22）：pathsByKey 原先是「模块生命周期内永不释放」的集合——
+    // 写入点只有 capturePaths（每会话一条），全文件零 delete/clear；且 disposeAll 走本函数，
+    // 连全量退出路径也清不掉 ⇒ findProvenance 会在已释放的 runtime 上命中陈旧快照。
+    // 键口径与 :316/:482/:683 三处读点一致（String(runtime.key || '')）。
+    pathsByKey.delete(String(runtime.key || ''))
   }
   function disposeAll(reason) {
     for (const pair of collectStates()) disposeRuntime(pair.runtime)

package/lib/episodic-store.js

@@ -121,15 +121,43 @@ export function createEpisodicStorePre(opts = {}) {
     return raw
   }
 
+  /**
+   * ★ P2-2 修复(2026-09-21)：查询返回**深一层副本**。
+   * 旧实现 `{ ...e }` 是浅拷贝 ⇒ `actions/entities/unresolved/provenance` 四个数组
+   * 与库内对象**同引用**，调用方 push 会直接改脏已巩固 episode(绕过 persist 与统计)。
+   */
+  function cloneEpisode(e) {
+    if (!e) return e
+    return {
+      ...e,
+      actions: Array.isArray(e.actions) ? [...e.actions] : e.actions,
+      entities: Array.isArray(e.entities) ? [...e.entities] : e.entities,
+      unresolved: Array.isArray(e.unresolved) ? [...e.unresolved] : e.unresolved,
+      provenance: Array.isArray(e.provenance) ? [...e.provenance] : e.provenance,
+    }
+  }
+
   // ---- 段追加(会话进行中实时累积) ----
   function append(seg) {
     if (disposed) return { ok: false, reason: 'disposed' }
     const v = validateEpisodeSegmentPre(seg)
     if (!v.ok) return { ok: false, reason: v.reason }
     const s = v.segment
+    const incomingRef = String(s.sessionRef || 'unknown')
+    // ★ A-7 修复(2026-09-21)：**按 sessionRef 隔离**。
+    //   旧实现只在 `!current` 时取一次 sessionRef ⇒ 后续不同会话的段被并进同一个 episode:
+    //   实测 sessionRef=session-A 但 intent 含 session-B 内容、provenance=["seg:1","seg:1"]。
+    //   后果:procedure 晋升依赖的 distinctSessions 被系统性低估 ⇒ 技能永远卡在
+    //   `diversity-below-3`(跨会话证据明明够,读数却恒为 1)。
+    //   现改为:检测到会话切换时,**先巩固当前缓冲**(把上一会话的段固化成一个独立 episode),
+    //   再为新的 sessionRef 开一个干净的 current。consolidate 失败(如 too-short)不阻断本段,
+    //   其内部已负责把 current 置 null,后续照常新建。
+    if (current && current.sessionRef !== incomingRef) {
+      consolidate()
+    }
     if (!current) {
       current = {
-        sessionRef: String(s.sessionRef || 'unknown'),
+        sessionRef: incomingRef,
         startedAt: nowFn(),
         segments: [],
         userTexts: [], assistantTexts: [],
@@ -156,7 +184,13 @@ export function createEpisodicStorePre(opts = {}) {
       if (current.assistantTexts.length) current.assistantTexts.shift()
     }
     stats.segmentsAppended++
-    return { ok: true, segments: current.segments.length }
+    // ★ P2-11 修复(2026-09-21)：append 此前**完全不落盘** —— 段只留在内存，
+    //   进程重启(崩溃/宿主重载)后未巩固的会话缓冲整段丢失，而调用方看到 ok:true。
+    //   现在按段落盘(与 fact-store 各写路径一致)。落盘结果一并透传(A-8 同款纪律)。
+    const pr = persist()
+    return pr.ok
+      ? { ok: true, segments: current.segments.length, persisted: true }
+      : { ok: true, segments: current.segments.length, persisted: false, persistError: pr.error }
   }
 
   /** 从累积文本提取 intent(2026-08-28 提纯;2026-09-16 issue#30 改为共享清洗器)。
@@ -232,13 +266,24 @@ export function createEpisodicStorePre(opts = {}) {
       unresolved: extractUnresolved(current),
       outcome,
       success: outcome === 'success',
-      provenance: current.segments.map((s) => 'seg:' + String(s.eventSeq)),
+      // ★ A-7 修复(2026-09-21)：provenance 改为 **`sessionRef:eventSeq`**。
+      //   旧实现只用 `'seg:' + eventSeq` ⇒ 不同会话里 eventSeq 从 1 重新计数时
+      //   会产出完全相同的串(实测 ["seg:1","seg:1"]),既无法溯源到会话,
+      //   也让"同一段被重复计入"与"两段恰好同号"在审计面上不可区分。
+      provenance: current.segments.map((s) => String(current.sessionRef) + ':' + String(s.eventSeq)),
       startedAt: current.startedAt,
       consolidatedAt: nowFn(),
     }
     const v = validateEpisodePre(ep)
     if (!v.ok) { current = null; return { ok: false, reason: 'invalid:' + v.reason } }
-    episodes.push(v.episode)
+    // ★ P2-11 修复(2026-09-21)：巩固入店前按 **episodeId 去重**。
+    //   episodeId = hash(sessionRef, startedAt) ⇒ 同一会话在同一时间戳被重复巩固
+    //   (或 restore/import 已带入同 id 记录)会产出**同一主键的第二条**，
+    //   下游 query/statsFor 会把一次会话数成两次 ⇒ distinctSessions/success 读数虚高。
+    //   去重策略:**后到者胜**(原地替换,不打乱既有顺序),与 fact-store restore 一致。
+    const dupAt = episodes.findIndex((x) => x.episodeId === v.episode.episodeId)
+    if (dupAt >= 0) episodes[dupAt] = v.episode
+    else episodes.push(v.episode)
     // 保留策略: 超 retention 淘汰最旧
     if (episodes.length > cfg.retention) {
       episodes = episodes.slice(-cfg.retention)
@@ -246,8 +291,10 @@ export function createEpisodicStorePre(opts = {}) {
     }
     current = null
     stats.consolidated++
-    void persist()
-    return { ok: true, episode: v.episode }
+    const pr = persist()
+    return pr.ok
+      ? { ok: true, episode: v.episode, persisted: true }
+      : { ok: true, episode: v.episode, persisted: false, persistError: pr.error }
   }
 
   /** 会话中途强制巩固(跨天续接/会话切换时调用)。 */
@@ -264,14 +311,14 @@ export function createEpisodicStorePre(opts = {}) {
         (q.sessionRef === undefined || e.sessionRef === q.sessionRef) &&
         (q.outcome === undefined || e.outcome === q.outcome) &&
         (q.success === undefined || e.success === q.success))
-      .map((e) => ({ ...e }))
+      .map(cloneEpisode)
   }
   function recent(n = 10) {
-    return episodes.slice(-n).map((e) => ({ ...e }))
+    return episodes.slice(-n).map(cloneEpisode)
   }
   function get(episodeId) {
     const e = episodes.find((x) => x.episodeId === episodeId)
-    return e ? { ...e } : null
+    return e ? cloneEpisode(e) : null
   }
 
   // ---- M-04 挂钩: 供 Procedure 晋升用的事故/成功统计 ----
@@ -290,10 +337,12 @@ export function createEpisodicStorePre(opts = {}) {
     return {
       schemaVersion: 1, namespace: 'dsh-auto-memory', policyVersion: EPISODIC_POLICY_VERSION,
       savedAt: nowFn(),
-      episodes: episodes.map((e) => ({ ...e })),
+      // ★ P2-2 修复：快照数组字段同样做副本(调用方改快照不得改脏库内 episode)
+      episodes: episodes.map(cloneEpisode),
       current: current ? {
         sessionRef: current.sessionRef, startedAt: current.startedAt,
-        segments: current.segments, userTexts: current.userTexts, assistantTexts: current.assistantTexts,
+        segments: current.segments.map((s) => ({ ...s })),
+        userTexts: [...current.userTexts], assistantTexts: [...current.assistantTexts],
       } : null,
     }
   }
@@ -344,22 +393,47 @@ export function createEpisodicStorePre(opts = {}) {
   }
   function clear() {
     episodes = []; current = null
-    try { io.clear() } catch (_) {}
-    return { ok: true }
+    // ★ A-8：io.clear() 失败不得静默(残留快照会在下次 load 时"复活"已清空的 episode)
+    let cleared = true, clearError
+    try { io.clear() } catch (e) {
+      cleared = false
+      clearError = (e && e.message) ? String(e.message) : String(e)
+    }
+    return clearError !== undefined ? { ok: true, cleared, error: clearError } : { ok: true, cleared }
   }
   function dispose(reason) {
-    if (disposed) return
+    if (disposed) return { ok: true, persisted: true, alreadyDisposed: true }
     disposed = true
-    try { io.save(snapshot()) } catch (_) {}
+    // ★ A-8：dispose 是最后一次落盘机会，失败必须外显
+    const r = persist()
+    return { ok: r.ok, persisted: r.ok, ...(r.error ? { error: r.error } : {}) }
   }
 
+  /**
+   * ★ A-8 修复(2026-09-21)：旧实现 `try { io.save(snapshot()) } catch (_) {}` **吞掉落盘失败** ——
+   * 调用方看到 ok:true、宿主继续推进状态，但磁盘没写上，该状态**永不重写**(静默数据丢失)。
+   * 现改为:① 返回结构化结果 `{ok, persisted}`(失败时附 error 文案); ② 失败记进模块内可读状态
+   * `lastPersistError`(经 `getLastPersistError()` 暴露)。不引入任何新 import。
+   * @returns {{ok:boolean, persisted:boolean, error?:string}}
+   */
+  let lastPersistError = null
   function persist() {
-    try { io.save(snapshot()) } catch (_) {}
+    try {
+      io.save(snapshot())
+      lastPersistError = null
+      return { ok: true, persisted: true }
+    } catch (e) {
+      const msg = (e && e.message) ? String(e.message) : String(e)
+      lastPersistError = msg
+      return { ok: false, persisted: false, error: msg }
+    }
   }
 
   return {
     append, consolidate, flush, query, recent, get, statsFor,
     snapshot, restore, importEpisodes, clear, dispose,
+    /** ★ A-8：最近一次落盘失败(字符串)或 null —— 供宿主诊断"写盘失败但流程继续"的静默缺口。 */
+    getLastPersistError: () => lastPersistError,
     getStats: () => ({ ...stats }),
     get size() { return episodes.length },
     get hasCurrent() { return !!current },

package/lib/evidence-store.js

@@ -95,6 +95,23 @@ export function parseDurableEventLine(line) {
 
 // ========== Store(appen-only JSONL,engine 级串行链) ==========
 
+/**
+ * ★P3-9（组2，2026-09-22）：诊断**节流**表。
+ * 原先 `_writeLine` 每次写失败都直接 console.error ⇒ 持续失败（磁盘满/权限错）时刷屏。
+ * 表放**模块级**而非实例级：同进程多实例共享 ⇒ 不会各自持一份而双写。
+ * 语义同 index.js 的 diagThrottled：首条立即透出，窗口内重复压掉。
+ */
+const DIAG_THROTTLE_MS_V1 = 300000
+const _diagAt = new Map()
+function shouldReportDiag(key) {
+  try {
+    const now = Date.now()
+    if (now - (Number(_diagAt.get(key)) || 0) < DIAG_THROTTLE_MS_V1) return false
+    _diagAt.set(key, now)
+  } catch (_) { /* 计时失败不阻断上报 */ }
+  return true
+}
+
 export class EvidenceEventStore {
   constructor(opts = {}) {
     this.root = opts.root || null
@@ -103,6 +120,15 @@ export class EvidenceEventStore {
     this._appended = new BoundedIdSet(EVIDENCE_STORE_POLICY_V1.appendedIdCache)
     this._swept = false
     this.stats = { appended: 0, duplicates: 0, oversize: 0, invalid: 0, writeFailed: 0, sweptFiles: 0, lastWriteError: null }
+    // ★P3-9（组2）：可注入诊断通道（宿主不注入时 reportDiag 回落 console.error，行为向后兼容）。
+    this._onDiag = typeof opts.onDiag === 'function' ? opts.onDiag : null
+  }
+
+  /** ★P3-9（组2）：节流上报。首条立即透出，窗口内重复压掉。 */
+  reportDiag(key, msg) {
+    if (!shouldReportDiag(key)) return
+    if (this._onDiag) { try { this._onDiag(key, msg); return } catch (_) { /* 回落 */ } }
+    try { console.error(msg) } catch (_) {}
   }
 
   /** §9 幂等:同 evidenceId 进程内只落盘一次(seed replay 与 live 双喂安全网;磁盘侧靠 rebuild 去重兜底)。 */
@@ -140,7 +166,7 @@ export class EvidenceEventStore {
     } catch (e) {
       this.stats.writeFailed++
       this.stats.lastWriteError = String(e && e.message ? e.message : e)
-      try { console.error('[evidence-store] write-failed: ' + this.stats.lastWriteError) } catch (_) {}
+      try { this.reportDiag('evidence:write-failed', '[evidence-store] write-failed: ' + this.stats.lastWriteError) } catch (_) {}
       return false
     }
   }