@a9i5k4/dsh-auto-memory 2.5.3 → 3.0.1

package/lib/engine-switch.js

@@ -0,0 +1,247 @@
+/**
+ * 引擎切换状态机（engine_switch_v1）—— P2 / T2-9 切档隔离与进度条（V2-P2 卡 points 4/5）。
+ *
+ * 权威依据（评审 §3.5 采纳条目 + V2-P2 卡）：
+ *   · **切档 = 强制全量重建 + 进度条**（用户裁定）：每次**实际切换**创建**新 rebuild generation**，
+ *     目标重建**不复用旧代一二级缓存**（含 e5→BGE→e5）；完成后恢复日常增量。
+ *   · **进度只能有一个真实所有者**：本模块持有唯一进度状态；`semantic-status` 与向导只**投影**它，
+ *     不自行维护第二套计数（python-setup 的 status 只读投影，见 index.js semantic-status 接线）。
+ *   · **保存后才启动切换**：调用方在配置落盘后调 `beginEngineSwitchPre`，不由下拉框未保存值驱动。
+ *   · **进度只能来自实际完成量**：`done` 由 `reportScopeDone` 逐项累加；**manifest 发布前不得显示整体完成**
+ *     （`phase` 未到 'ready' 前 `indexReady` 恒 false，即便 done==total 也须等 `publish`）。
+ *   · **A 未完成又发起 B**：B 使 A 作废（superseded）；**A 迟到不能发布 B 的 ready**（switchId 校验）。
+ *   · **同一 switchId 重试不重复编码**：已完成（ready）的同 id 再次 begin 直接返回现状，不重跑。
+ *   · **编码中暂停 / 校验失败 / 发布失败 / 重启恢复**：状态可持久化（IO 注入），重启后 running → interrupted，
+ *     `done` 保留（来自实际完成量），下次 begin 或 resume 继续。
+ *
+ * 状态字段（最小投影，不泄内容）：
+ *   {switchId, generation, phase, fromIdentity, toIdentity, total, done, failed, error,
+ *    startedAt, updatedAt, finishedAt, supersededBy, published}
+ *   phase ∈ idle | running | interrupted | publishing | ready | failed | cancelled
+ *
+ * 零第三方依赖；IO 全注入（不传则纯内存）；UTF-8 无 BOM。
+ */
+
+export const ENGINE_SWITCH_VERSION = 'engine_switch_v1'
+
+/** 终态：到达后不再变化（除 begin 开新代）。 */
+const TERMINAL = new Set(['ready', 'failed', 'cancelled'])
+
+function nowOf(opts) { return typeof opts.now === 'function' ? Number(opts.now()) || 0 : Date.now() }
+
+/**
+ * @param {object} opts
+ * @param {()=>number} [opts.now] 时间注入（测试确定性）
+ * @param {{readJson?:(p:any)=>any, writeJson?:(p:any,o:any)=>void}} [opts.io] 持久化 IO（缺省纯内存）
+ * @param {string} [opts.persistPath] 状态文件路径（提供且 io 可用时才落盘）
+ * @param {(msg:string)=>void} [opts.diag]
+ */
+export function createEngineSwitchPre(opts = {}) {
+  const io = opts.io || null
+  const persistPath = opts.persistPath ? String(opts.persistPath) : ''
+  const diagFn = typeof opts.diag === 'function' ? opts.diag : () => {}
+  const safeDiag = (m) => { try { diagFn(String(m).slice(0, 200)) } catch (_) {} }
+
+  let generation = 0
+  let state = {
+    switchId: '', generation: 0, phase: 'idle',
+    fromIdentity: '', toIdentity: '', total: 0, done: 0, failed: 0,
+    error: '', supersededBy: '', published: false,
+    startedAt: 0, updatedAt: 0, finishedAt: 0,
+  }
+  // 同代内"已处理单元"集合：同 switchId 重试/恢复时跳过（不重复编码）
+  let doneUnits = new Set()
+
+  function snapshot() {
+    return {
+      ...state,
+      doneUnits: doneUnits.size,
+      indexReady: state.phase === 'ready' && state.published === true,
+      version: ENGINE_SWITCH_VERSION,
+    }
+  }
+
+  function persist() {
+    if (!persistPath || !io || typeof io.writeJson !== 'function') return
+    try {
+      io.writeJson(persistPath, {
+        version: ENGINE_SWITCH_VERSION,
+        generation, state: { ...state },
+        doneUnits: [...doneUnits],
+      })
+    } catch (e) { safeDiag('engine-switch persist fail: ' + ((e && e.message) || e)) }
+  }
+
+  /** 启动恢复：running → interrupted（进度保留 = 实际完成量）；ready 保持。 */
+  function restore() {
+    if (!persistPath || !io || typeof io.readJson !== 'function') return
+    let raw = null
+    try { raw = io.readJson(persistPath) } catch (_) { return }
+    if (!raw || typeof raw !== 'object') return
+    try {
+      const st = raw.state && typeof raw.state === 'object' ? raw.state : null
+      if (!st) return
+      generation = Number(raw.generation) || 0
+      state = {
+        switchId: String(st.switchId || ''), generation: Number(st.generation) || generation,
+        phase: String(st.phase || 'idle'),
+        fromIdentity: String(st.fromIdentity || ''), toIdentity: String(st.toIdentity || ''),
+        total: Number(st.total) || 0, done: Number(st.done) || 0, failed: Number(st.failed) || 0,
+        error: String(st.error || ''), supersededBy: String(st.supersededBy || ''),
+        published: st.published === true,
+        startedAt: Number(st.startedAt) || 0, updatedAt: Number(st.updatedAt) || 0, finishedAt: Number(st.finishedAt) || 0,
+      }
+      if (Array.isArray(raw.doneUnits)) doneUnits = new Set(raw.doneUnits.map(String))
+      // ★T2-9c 重启恢复：**未完成的 running 一律降级为 interrupted**（进程已换代），
+      // 进度保持"实际完成量"，不假装完成；indexReady 仍为 false（published 未置位）。
+      if (state.phase === 'running' || state.phase === 'publishing') {
+        state.phase = 'interrupted'
+        state.error = state.error || 'interrupted-by-restart'
+        state.updatedAt = nowOf(opts)
+        persist()
+      }
+    } catch (e) { safeDiag('engine-switch restore fail: ' + ((e && e.message) || e)) }
+  }
+  restore()
+
+  /**
+   * 开始一次**实际**引擎切换（保存配置之后调用）。
+   * @returns {{ok:boolean, switchId:string, generation:number, reason?:string, resumed?:boolean}}
+   *  - 同一 switchId 且已 ready → 直接返回现状（**不重复编码**，T2-9b 幂等）。
+   *  - 同一 switchId 且 running/interrupted → 恢复续跑（done 保留）。
+   *  - 新 switchId → generation+1，作废旧的在飞切换（supersededBy），清空进度重新计。
+   */
+  function beginEngineSwitchPre(input = {}) {
+    const switchId = String(input.switchId || '').trim()
+    const toIdentity = String(input.toIdentity || '').trim()
+    const fromIdentity = String(input.fromIdentity || state.toIdentity || '').trim()
+    const total = Number(input.total) > 0 ? Math.floor(Number(input.total)) : 0
+    if (!switchId) return { ok: false, switchId: '', generation, reason: 'no-switch-id' }
+    if (!/^engid_[0-9a-f]{32}$/.test(toIdentity)) return { ok: false, switchId, generation, reason: 'bad-identity' }
+    // 幂等：同 id 已完成 → 不重跑
+    if (state.switchId === switchId && state.phase === 'ready' && state.toIdentity === toIdentity) {
+      return { ok: true, switchId, generation: state.generation, reason: 'already-ready' }
+    }
+    // 续跑：同 id 未完成 → 保留 done/doneUnits
+    if (state.switchId === switchId && (state.phase === 'running' || state.phase === 'interrupted')) {
+      state.phase = 'running'
+      if (total > 0) state.total = total
+      state.updatedAt = nowOf(opts)
+      persist()
+      return { ok: true, switchId, generation: state.generation, resumed: true }
+    }
+    // 新切换：作废旧代（A 迟到不得发布 B 的 ready）
+    const prevSwitchId = state.switchId
+    if (prevSwitchId && !TERMINAL.has(state.phase)) state.supersededBy = switchId
+    generation = (Number(state.generation) || generation) + 1
+    doneUnits = new Set()
+    const t = nowOf(opts)
+    state = {
+      switchId, generation, phase: 'running',
+      fromIdentity, toIdentity, total, done: 0, failed: 0,
+      error: '', supersededBy: '', published: false,
+      startedAt: t, updatedAt: t, finishedAt: 0,
+    }
+    persist()
+    return { ok: true, switchId, generation, fresh: true, superseded: prevSwitchId || '' }
+  }
+
+  /**
+   * 报告一批实际完成的单元（由索引侧在**真实完成编码/同步**后调用）。
+   * 幂等：同一 unitKey 重复上报不重复计数（同一 switchId 重试不重复编码）。
+   */
+  function reportDone(switchId, unitKeys, opts2 = {}) {
+    if (state.switchId !== switchId) return { ok: false, reason: 'stale-switch' } // A 迟到不算数
+    if (state.phase !== 'running' && state.phase !== 'publishing') return { ok: false, reason: 'not-running' }
+    const keys = (Array.isArray(unitKeys) ? unitKeys : [unitKeys]).map(String).filter(Boolean)
+    let added = 0
+    for (const k of keys) { if (!doneUnits.has(k)) { doneUnits.add(k); added++ } }
+    state.done = doneUnits.size
+    if (Number(opts2.total) > 0) state.total = Math.floor(Number(opts2.total))
+    state.updatedAt = nowOf(opts)
+    persist()
+    return { ok: true, done: state.done, added }
+  }
+
+  /** 记录失败单元数（不影响 done；T2-9d：失败要让词法仍可用 + 原因可见）。 */
+  function reportFailed(switchId, n = 1, reason = '') {
+    if (state.switchId !== switchId) return { ok: false, reason: 'stale-switch' }
+    state.failed += Math.max(0, Math.floor(Number(n) || 0))
+    if (reason) state.error = String(reason).slice(0, 160)
+    state.updatedAt = nowOf(opts)
+    persist()
+    return { ok: true, failed: state.failed }
+  }
+
+  /**
+   * 发布 manifest → 进入 ready（**整体完成只能在这里之后显示**）。
+   * A 迟到发布：如果当前 state.switchId 不是它，直接拒绝（T2-9b）。
+   */
+  function publishReady(switchId) {
+    if (state.switchId !== switchId) return { ok: false, reason: 'stale-switch' }
+    if (state.phase !== 'running' && state.phase !== 'publishing' && state.phase !== 'interrupted') {
+      return { ok: false, reason: 'bad-phase' }
+    }
+    state.phase = 'ready'
+    state.published = true
+    state.updatedAt = nowOf(opts)
+    state.finishedAt = state.updatedAt
+    persist()
+    return { ok: true, indexReady: true }
+  }
+
+  /** 校验失败 / 发布失败：进入 failed，原因可见（词法侧不受影响）。 */
+  function failSwitch(switchId, reason = '') {
+    if (state.switchId !== switchId) return { ok: false, reason: 'stale-switch' }
+    state.phase = 'failed'
+    state.error = String(reason || 'failed').slice(0, 160)
+    state.published = false
+    state.updatedAt = nowOf(opts)
+    state.finishedAt = state.updatedAt
+    persist()
+    return { ok: true }
+  }
+
+  /** 用户取消（或切档前放弃）：进入 cancelled；进度保留在读数里可审计。 */
+  function cancelEngineSwitchPre(switchId) {
+    const id = String(switchId || state.switchId || '')
+    if (!id || state.switchId !== id) return { ok: false, reason: 'stale-switch' }
+    if (TERMINAL.has(state.phase) && state.phase !== 'ready') return { ok: false, reason: 'bad-phase' }
+    state.phase = 'cancelled'
+    state.published = false
+    state.updatedAt = nowOf(opts)
+    state.finishedAt = state.updatedAt
+    persist()
+    return { ok: true }
+  }
+
+  /** 计划总量（调用方在拿到冻结快照后设定；只影响进度分母）。 */
+  function setTotal(switchId, total) {
+    if (state.switchId !== switchId) return { ok: false, reason: 'stale-switch' }
+    state.total = Math.max(0, Math.floor(Number(total) || 0))
+    if (state.total && state.done > state.total) state.done = doneUnits.size = Math.min(doneUnits.size, state.total)
+    state.updatedAt = nowOf(opts)
+    persist()
+    return { ok: true }
+  }
+
+  function getEngineSwitchStatusPre() { return snapshot() }
+
+  /** 当前代是否要求"强制全量重建"（running/interrupted 时 true；ready/cancelled/idle 时 false）。 */
+  function requiresFullRebuild() { return state.phase === 'running' || state.phase === 'interrupted' }
+
+  return {
+    version: ENGINE_SWITCH_VERSION,
+    beginEngineSwitchPre,
+    cancelEngineSwitchPre,
+    getEngineSwitchStatusPre,
+    reportDone,
+    reportFailed,
+    publishReady,
+    failSwitch,
+    setTotal,
+    requiresFullRebuild,
+    _stateForTest: () => state,
+    _doneUnitsForTest: () => doneUnits,
+  }
+}

package/lib/episodic-store.js

@@ -1,3 +1,4 @@
+import { stripRuntimeIntentPre } from './intent-clean-safe.js'
 /**
  * M8-1 Episodic Store 纯核心(docs/proactive-associative-memory-system-map.html M-02 Episodic)。
  * 纯内存状态机,零 IO、零依赖(node:crypto 仅作确定性身份);持久化通过可注入 IO 接口,
@@ -99,10 +100,27 @@ export function createEpisodicStorePre(opts = {}) {
   const stats = { segmentsAppended: 0, consolidated: 0, droppedTooShort: 0, retained: 0 }
 
   function defaultEpisodeId(sessionRef, startedAt) {
-    const h = createHash('sha256').update(['episode-pre-v1', String(sessionRef), String(startedAt)].join('\u0000')).digest('hex')
+    const h = createHash('sha256').update(['episode-v1', String(sessionRef), String(startedAt)].join('\u0000')).digest('hex')
     return EPISODE_ID_PREFIX + h.slice(0, 32)
   }
 
+  /**
+   * issue#57 修复(2026-09-19):restore 时对 `data.current` 做**形状校验**。
+   * 旧实现 `current = data.current || null` 零校验(与 :222 的 validateEpisodePre 形成不对称):
+   * 磁盘上 `current:{}`(截断/手改/旧版本残留)会被原样采纳 ⇒ 之后 consolidate() 在
+   * `current.segments.length`(:202)抛 TypeError ⇒ **巩固链路静默停摆**,且因异常发生在
+   * 调用方 try 之外,统计与日志都不留痕。
+   * 纪律:**丢弃优于卡死** —— 形状不合格一律置 null(等效"本会话无未巩固缓冲"),
+   * 绝不把结构非法对象放进状态机。
+   */
+  function restoreCurrentPre(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null
+    if (typeof raw.sessionRef !== 'string' || !raw.sessionRef) return null
+    if (typeof raw.startedAt !== 'number' || !Number.isFinite(raw.startedAt)) return null
+    if (!Array.isArray(raw.segments) || !Array.isArray(raw.userTexts) || !Array.isArray(raw.assistantTexts)) return null
+    return raw
+  }
+
   // ---- 段追加(会话进行中实时累积) ----
   function append(seg) {
     if (disposed) return { ok: false, reason: 'disposed' }
@@ -118,7 +136,8 @@ export function createEpisodicStorePre(opts = {}) {
       }
     }
     // 累积文本(只保留文本特征,不保留原文全文 —— 隐私最小化)
-    const ut = typeof s.userText === 'string' ? s.userText : ''
+    // issue#30:入库时就剥离运行时信封,避免注入快照一路流到 intent/title(下游只做兜底清洗)。
+    const ut = stripRuntimeIntentPre(typeof s.userText === 'string' ? s.userText : '')
     const at = typeof s.assistantText === 'string' ? s.assistantText : ''
     if (ut.trim()) current.userTexts.push(ut.trim().slice(0, 200))
     if (at.trim()) current.assistantTexts.push(at.trim().slice(0, 200))
@@ -140,15 +159,14 @@ export function createEpisodicStorePre(opts = {}) {
     return { ok: true, segments: current.segments.length }
   }
 
-  /** 从累积文本提取 intent(2026-08-28 提纯):跳过本插件注入快照污染的段
-   *  (「Current runtime context. This snapshot…」/auto-memory 标记),取第一条
-   *  真实用户文本;全被污染则取最后一条(退化)。 */
+  /** 从累积文本提取 intent(2026-08-28 提纯;2026-09-16 issue#30 改为共享清洗器)。
+   *  旧实现用一条正则猜"像注入"的文本,而注入形态会演进(新增标签/换行拼法)⇒ 漏判后
+   *  污染文本进入 intent,再经 hub 变成"观察型 procedure"的 title。现在复用
+   *  `stripRuntimeIntentPre`(与 intent-clean 同源),按**行边界**剥离运行时信封,
+   *  保留代码块/引用块内的字面示例,避免误删真实文本。 */
   function extractIntent(ep) {
-    const INJECTED_RE = /^current runtime context\.|^this snapshot supersedes|auto-memory|\[自动沉淀\]/i
-    const texts = (ep.userTexts || []).map((t) => String(t || '').trim()).filter((t) => t)
-    const clean = texts.filter((t) => !INJECTED_RE.test(t))
-    const pick = clean.length ? clean[0] : (texts.length ? texts[texts.length - 1] : '')
-    return pick ? pick.slice(0, 60) : '(未提取)'
+    const clean = (ep.userTexts || []).map((t) => stripRuntimeIntentPre(t).trim()).filter(Boolean)
+    return clean.length ? clean[0].slice(0, 60) : ''
   }
 
   /** 从累积文本提取 entities(简单启发式:用户文本中的 CJK 2-4 字符 token,高频优先)。 */
@@ -279,6 +297,39 @@ export function createEpisodicStorePre(opts = {}) {
       } : null,
     }
   }
+  /**
+   * ★ 增量导入（2026-09-19 上游 PR #77 / issue #63 同步落地，**P0 数据丢失**）。
+   *
+   * **为什么必须单独有这个函数**：hub 的 `ingestJudgement` 原本对每行 `episodic_candidate`
+   * 调 `restore({schemaVersion:1, episodes:[row]})`，而 `restore()` 是**快照整体替换**语义
+   * （先 `episodes = []`）。worker 产出的候选行普遍缺 `validateEpisodePre` 必填字段
+   * ⇒ 校验必拒（`restored:0`），**但 episodes 已被清空、current 已被置 null**，
+   * 且 `restore()` 仍返回 `{ok:true}` ⇒ hub 记 `consumedEpisodic++` / `outcome:'restored'`
+   * ⇒ 下次 consolidate/flush 把清空态落盘 ⇒ **一次 ingest 抹掉全部已巩固 episode，不可逆**。
+   *
+   * 契约（与 `restore` 严格区分）：
+   *  - **绝不清空既有状态**（不清 episodes、不动 current）；
+   *  - 逐条校验，**只追加合法项**，非法项计入 `rejected`（不静默）；
+   *  - 按 `episodeId` **幂等去重**（重复导入同一行不产生副本）；
+   *  - **不持久化**（由调用方决定何时 flush），与 `restore` 一致。
+   * @param {Array} rows - 候选 episode 行（原始形态，内部走 validateEpisodePre）
+   * @returns {{ok: boolean, imported: number, rejected: number, duplicates: number, reason?: string}}
+   */
+  function importEpisodes(rows) {
+    if (!Array.isArray(rows)) return { ok: false, imported: 0, rejected: 0, duplicates: 0, reason: 'bad-rows' }
+    let imported = 0, rejected = 0, duplicates = 0
+    const seen = new Set(episodes.map((e) => e.episodeId))
+    for (const raw of rows) {
+      const v = validateEpisodePre(raw)
+      if (!v.ok) { rejected++; continue }
+      if (seen.has(v.episode.episodeId)) { duplicates++; continue }
+      episodes.push(v.episode)
+      seen.add(v.episode.episodeId)
+      imported++
+    }
+    return { ok: true, imported, rejected, duplicates }
+  }
+
   function restore(data) {
     if (!data || data.schemaVersion !== 1) return { ok: false, reason: 'bad-schema' }
     if (!Array.isArray(data.episodes)) return { ok: false, reason: 'bad-episodes' }
@@ -288,7 +339,7 @@ export function createEpisodicStorePre(opts = {}) {
       if (!v.ok) continue
       episodes.push(v.episode)
     }
-    current = data.current || null
+    current = restoreCurrentPre(data.current)
     return { ok: true, restored: episodes.length }
   }
   function clear() {
@@ -308,7 +359,7 @@ export function createEpisodicStorePre(opts = {}) {
 
   return {
     append, consolidate, flush, query, recent, get, statsFor,
-    snapshot, restore, clear, dispose,
+    snapshot, restore, importEpisodes, clear, dispose,
     getStats: () => ({ ...stats }),
     get size() { return episodes.length },
     get hasCurrent() { return !!current },

package/lib/evidence-store.js

@@ -32,12 +32,12 @@ export function canonicalWorkspaceKey(key) {
 
 /** §10 隐私投影:sessionId → plugin-local sessionRef(不可逆哈希;跨文件稳定)。 */
 export function sessionRefOf(sessionId) {
-  return 'sesr_' + first32(sha256Str('evidence-sesref-pre-v1\u0000' + String(sessionId || '')))
+  return 'sesr_' + first32(sha256Str('evidence-sesref-v1\u0000' + String(sessionId || '')))
 }
 
 /** §10 隐私投影:workspace 绝对键 → 稳定 workspaceRef(不落盘任何绝对路径)。 */
 export function workspaceRefOf(workspaceKey) {
-  return 'wsr_' + first32(sha256Str('evidence-wsref-pre-v1\u0000' + canonicalWorkspaceKey(workspaceKey)))
+  return 'wsr_' + first32(sha256Str('evidence-wsref-v1\u0000' + canonicalWorkspaceKey(workspaceKey)))
 }
 
 /**
@@ -118,7 +118,14 @@ export class EvidenceEventStore {
     }
     if (id) this._appended.add(id)
     this._chain = this._chain.then(() => this._writeLine(proj.line))
-    return this._chain.then((written) => ({ ok: written, reason: written ? 'ok' : 'write-failed', evidenceId: id, projected: proj.projected }))
+    return this._chain.then((written) => {
+      // issue#56 修复(2026-09-19):写盘失败必须**释放幂等登记**。
+      // 旧实现只 add 从不回退 ⇒ 一次瞬时写失败后,同 evidenceId 的重试恒被判
+      // duplicate-evidence 而拒绝 ⇒ 该条证据**静默永久丢失**。
+      // 登记保留在调用时(维持同步去重窗口),失败时撤销(允许重试)。
+      if (!written && id) this._appended.delete(id)
+      return { ok: written, reason: written ? 'ok' : 'write-failed', evidenceId: id, projected: proj.projected }
+    })
   }
 
   async _writeLine(line) {

package/lib/fact-store.js

@@ -148,7 +148,7 @@ export function createFactStorePre(opts = {}) {
   // ---- 确定性 factId(与 memoryId/anchorId 同风格) ----
   function defaultFactId(subject, predicate, object, scope) {
     const h = createHash('sha256').update(
-      ['fact-pre-v1', String(scope), String(subject), String(predicate), String(object == null ? '' : object)].join('\u0000')
+      ['fact-v1', String(scope), String(subject), String(predicate), String(object == null ? '' : object)].join('\u0000')
     ).digest('hex')
     return FACT_ID_PREFIX + h.slice(0, 32)
   }
@@ -181,10 +181,17 @@ export function createFactStorePre(opts = {}) {
       // conflictId 必须唯一:同一候选值反复出现时,每次冲突都是独立待决事件。
       // 用 subject+predicate+object+序号+detectedAt 派生,保证可被逐个 resolve。
       conflictSeq++
+      // ★ 登记**检测时快照**而非活引用（2026-09-19 上游 PR #80 第 3 项 / issue #67 同步落地）：
+      //   旧实现 `left: existing` 持 store 内活对象引用 ⇒ 后续 merge 会**原地改写** existing.confidence
+      //   并对 existing.provenance **数组原地 push** ⇒ 已展示/已落盘（facts.json）的冲突左侧
+      //   ≠ 检测时的值 ⇒ 审计面失真（"当时判定冲突的两个值"被事后改写）。
+      //   故此处取快照，provenance 额外做数组副本。
       conflicts.push({
         conflictId: defaultFactId(c.scope, c.subject, c.predicate, c.object) + '_conflict_' + conflictSeq + '_' + String(now),
         scope: c.scope, subject: c.subject, predicate: c.predicate,
-        left: existing, right: c, detectedAt: now, resolved: false,
+        left: { ...existing, provenance: Array.isArray(existing.provenance) ? [...existing.provenance] : existing.provenance },
+        right: { ...c, provenance: Array.isArray(c.provenance) ? [...c.provenance] : c.provenance },
+        detectedAt: now, resolved: false,
       })
       void persist() // 冲突集是重要状态,必须落盘(不持久化会丢失待决冲突)
       return { ok: true, outcome: 'conflict-added', conflict: conflicts[conflicts.length - 1], existing }
@@ -384,7 +391,12 @@ export function createFactStorePre(opts = {}) {
   function clear() {
     facts = []; conflicts = []
     try { io.clear() } catch (_) {}
-    stats.created = 0; stats.merged = 0; stats.superseded = 0
+    // ★ issue #76-6c 修复（2026-09-19）：统计字段**全量归零**。
+    //   旧实现只写 `stats.created = 0; stats.merged = 0; stats.superseded = 0`，
+    //   漏掉 `upserts / conflictAdded / inferenceBlocked / expiredIgnored / revoked`
+    //   ⇒ clear() 后这些计数残留（实测），诊断读数与实际不符。
+    //   改为**按现有键遍历归零**，将来新增 stats 字段也不会再漏。
+    for (const k of Object.keys(stats)) stats[k] = 0
     return { ok: true }
   }
   function dispose(reason) {
@@ -396,6 +408,13 @@ export function createFactStorePre(opts = {}) {
   return {
     upsert, supersede, get, query, conflictsList, pendingConflicts, resolveConflict,
     evidenceFor, revokeBySource, snapshot, restore, clear, dispose,
+    // ★ issue #76-5 修复（2026-09-19）：把**模块级**的 judgement-row 消费器挂进实例。
+    //   旧实现 `memory-hub.js:81-84` 检查 `typeof stores.facts.factCandidateFromJudgementRow === 'function'`
+    //   以决定是否委托——但该函数此前**只是模块级导出**（见上方 `export function`），
+    //   不在 `createFactStorePre()` 的返回对象上 ⇒ **该分支恒假** ⇒ hub 恒走自己的本地副本
+    //   `factCandidateFromRow`（丢掉 `ttl` 字段，实测同输入下 store 版 ttl=60000、hub 版无 ttl）
+    //   ⇒ 两适配器从此各自演化。挂进实例后委托分支变为恒真，语义统一到 store 实现。
+    factCandidateFromJudgementRow,
     getStats: () => ({ ...stats }),
     get size() { return facts.length },
     get conflictCount() { return conflicts.length },

package/lib/fs-retry.js

@@ -0,0 +1,46 @@
+/**
+ * 有界 rename 重试 —— 应对 Windows 下短暂的文件句柄争用(issue #48)。
+ *
+ * 背景:Windows 上 DSH 常持有会话/记忆文件句柄(子代理刚结束时仍在写),
+ * 此时 `fs.rename` 抛 EPERM/EACCES/EBUSY。旧实现是"一次失败即硬失败",
+ * 在并发子代理场景下会把本可成功的写入判死。
+ *
+ * 语义边界:
+ * - delays 是**每次尝试之前的等待时长**,不是绝对时间戳;首项必须为 0(立即试一次)。
+ * - **不做** unlink/copy 回退:调用方各自保留自己的原子性与失败策略
+ *   (删源再拷会破坏原子性,一旦中途失败会同时丢源与目标)。
+ * - 仅对**瞬时**错误码重试;其它错误(如 ENOENT)立即抛出,不掩盖真实故障。
+ * - 用尽重试仍失败 → 抛出最后一次的原始错误(保留 code/path 等信息)。
+ */
+import { promises as fsDefault } from 'node:fs'
+import { setTimeout as sleepDefault } from 'node:timers/promises'
+
+export const RENAME_RETRY_DELAYS = Object.freeze([0, 50, 150, 400, 1000])
+const TRANSIENT_RENAME_CODES = new Set(['EPERM', 'EACCES', 'EBUSY'])
+
+/**
+ * 带退避的 rename。
+ * @param {string} from 源路径
+ * @param {string} to 目标路径
+ * @param {{fs?:object, delays?:number[], sleep?:Function}} [opts] 注入点(fs/sleep 供故障注入测试)
+ * @returns {Promise<void>} 成功即 resolve;失败抛原始错误
+ */
+export async function retryRename(from, to, opts = {}) {
+  const fsApi = opts.fs || fsDefault
+  const configuredDelays = opts.delays || RENAME_RETRY_DELAYS
+  const delays = Array.isArray(configuredDelays) ? configuredDelays.slice() : configuredDelays
+  const sleep = opts.sleep || sleepDefault
+  if (!Array.isArray(delays) || !delays.length || delays[0] !== 0 ||
+      delays.some((ms) => !Number.isFinite(ms) || ms < 0)) {
+    throw new TypeError('retryRename: delays must start with 0 and contain finite nonnegative waits')
+  }
+  for (let attempt = 0; attempt < delays.length; attempt++) {
+    if (delays[attempt]) await sleep(delays[attempt])
+    try {
+      await fsApi.rename(from, to)
+      return
+    } catch (error) {
+      if (!TRANSIENT_RENAME_CODES.has(error && error.code) || attempt === delays.length - 1) throw error
+    }
+  }
+}

package/lib/index-sync.js

@@ -16,7 +16,19 @@ import {
   M7_INDEX_POLICY_VERSION_V1,
 } from './m7-wire.js'
 
-export const INDEX_SYNC_PAGE_BUDGET_V1 = Object.freeze({ maxRecordsPerPage: 64, maxPageBytes: 256 * 1024 })
+/**
+ * ★ 页字节预算（2026-09-19 上游 PR #78 / issue #64 同步落地）。
+ *
+ * **为什么是 252KiB 而不是 256KiB**：`maxPageBytes` 只约束**页 payload**，
+ * 而 m7-wire 的 `MAX_LINE_BYTES` 是 **256KiB**，约束的是**整条线帧**（payload + 帧信封 + 换行）。
+ * 两者同为 256KiB ⇒ payload 落入约 231B 临界窗口的页 **builder 接受、线上必超限**
+ * ⇒ worker 判 `line-oversize` fail-closed 退出。
+ * 更糟的是叠加了死锁：① 熔断阈值 3，但每段 `index_sync_begin` 的成功帧把计数清零 ⇒ 峰值 2 永不熔断；
+ * ② `syncId` 由 recordCount **确定性派生** ⇒ 重试恒重建同一坏页 ⇒ 每 Segment 重生 worker、索引永不 ready。
+ *
+ * 故留 **4KiB 余量**（≈ 实测信封 202–230B 的 18 倍）。
+ */
+export const INDEX_SYNC_PAGE_BUDGET_V1 = Object.freeze({ maxRecordsPerPage: 64, maxPageBytes: 252 * 1024 })
 const SCOPE_ORDER_PRE = ['Workspace', 'User']
 
 function pagePayloadBytes(syncId, pageNo, pageCount, records) {