@a9i5k4/dsh-auto-memory 3.0.1 → 3.1.0

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)。 */
@@ -534,7 +535,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

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 },