@a9i5k4/dsh-auto-memory 2.5.3 → 3.0.0

package/lib/context-bridge.js

@@ -157,7 +157,7 @@ export function validateAccessEvidencePre(ev) {
 
 /** §4 canonical identity:observationId 由 sessionId+contextVersion+trigger digest+policy 决定。 */
 export function buildObservationId(sessionId, contextVersion, triggerDigest, policyVersion = CONTEXT_BRIDGE_POLICY_VERSION) {
-  const parts = ['context-push-pre-v1', String(sessionId || ''), Number(contextVersion) || 0, String(triggerDigest || ''), policyVersion]
+  const parts = ['context-push-v1', String(sessionId || ''), Number(contextVersion) || 0, String(triggerDigest || ''), policyVersion]
   return OBSERVATION_PREFIX + first32(sha256Str(JSON.stringify(parts)))
 }
 
@@ -388,7 +388,7 @@ export function createFakeContextSinkPre(opts = {}) {
       frames.push(JSON.parse(JSON.stringify(frame)))
       if (frames.length > capacity) frames.shift()
       stats.accepted++
-      return { observationId: id, accepted: true, workerEpoch: 'fake-epoch-pre-v1', reason: 'ok' }
+      return { observationId: id, accepted: true, workerEpoch: 'fake-epoch-v1', reason: 'ok' }
     },
     async closeSession() { stats.closedSessions++ },
     async dispose() { frames.length = 0 },

package/lib/context-host.js

@@ -104,6 +104,12 @@ export function createContextHost(opts = {}) {
   let lastFrameIdentity = null // 最小投影:observationId 全值(本身是哈希)+计数,无任何文本
   let lastSegmentRuntimeKey = null
   let lastSegmentSessionRef = null
+  // C5/I7:最近一次"索引未就绪"降级(可读、可观测;含原因与时间,不含任何语料文本)
+  // ★多工作区适配(2026-09-17):改为**按会话分片**。旧实现是单变量,任何会话的 index-not-ready
+  // 都写进去,而读取方(`index.js` 的 buildTierLayerInjection)只判 10 分钟时间窗、**不判会话**
+  // ⇒ B 会话的"未就绪"会把 A 会话污染十分钟,表现为**跨会话假降级**(A 明明正常却被标注降级)。
+  const indexDegradeBySession = new Map()
+  let lastIndexDegrade = null // 兼容投影:最近一次(供 debugView 等旧读取方)
   let lastSinkMode = null
   let bridge = null
   let store = null
@@ -347,14 +353,31 @@ export function createContextHost(opts = {}) {
         ? Promise.resolve().then(() => engine._jsSemanticRank(corpusSnap, buildObserveWindowText(runtime, seg))).catch(() => null)
         : Promise.resolve(null)
       void Promise.all([readyPromise, c2RankPromise]).then(([readyRes, rank]) => {
+        // C5/I7(2026-09-14):索引未就绪**不再静默丢弃注入**。旧行为是 pushDrop('index-not-ready:…')
+        // 后直接 return —— 语义索引一卡死,注入面就整段消失且无人知(07:43–08:35 的违规现场)。
+        // 新行为 = 显式降级 + fail-open:记一条可读降级(reason 进注入层 `[降级]` 行),本轮按**词法命中**
+        // 继续组装并推送 envelope(Tier-0 目录层照常常驻),稠密臂本轮不参与融合(不装懂)。
+        let indexNotReady = ''
         if (!(readyRes && readyRes.ready)) {
-          stats.pushesRejected++
-          pushDrop('index-not-ready:' + ((readyRes && readyRes.reason) || 'unknown'), runtime.contextVersion, runtime.key)
-          return
+          indexNotReady = String((readyRes && readyRes.reason) || 'unknown')
+          stats.indexDegraded = (stats.indexDegraded || 0) + 1
+          const sidDeg = String(runtime.sessionId || '')
+          const degradeRec = { reason: indexNotReady, at: Date.now(), sessionId: sidDeg }
+          // 多工作区适配(2026-09-17):按会话分片写入,读取方按会话取 ⇒ 不再跨会话污染。
+          indexDegradeBySession.set(sidDeg, degradeRec)
+          if (indexDegradeBySession.size > 32) {
+            const oldest = indexDegradeBySession.keys().next().value
+            indexDegradeBySession.delete(oldest)
+          }
+          lastIndexDegrade = degradeRec // 兼容投影(最近一次)
+          try { engine._lastIndexDegrade = degradeRec } catch (_) {}
+          try { engine._indexDegradeBySession = indexDegradeBySession } catch (_) {}
+          pushDrop('index-not-ready:degraded:' + indexNotReady, runtime.contextVersion, runtime.key)
+          diagCtx('ctx-host degrade: index-not-ready(' + indexNotReady + ') → 词法命中 + 常驻目录层继续注入')
         }
         if (st.disposed || runtime.disposed) return
         let keptList = ls.kept
-        if (rank && rank.scores && rank.scores.size) {
+        if (!indexNotReady && rank && rank.scores && rank.scores.size) {
           // D6 融合候选池=词法 kept ∪ 稠密 top-K(语料中找回记录对象;语义强命中但词法零分者由此入选)
           const poolMap = new Map()
           for (const k of ls.kept) if (k && k.memoryId) poolMap.set(k.memoryId, k)
@@ -463,14 +486,21 @@ export function createContextHost(opts = {}) {
                 const session = built.frame.session || {}
                 const cursor = built.frame.cursor || {}
                 const obs = built.frame.observationId || ''
+                // 2026-09-14 P1-⑮:注入侧 reason 串补 0-1 分值(intent/dense/margin)。
+                // 数值段置于 reasonCodes **之前**,160 字符截断只砍代码列表、不砍分值。
+                const num2 = (x) => (Number.isFinite(Number(x)) ? Number(x).toFixed(2) : '0.00')
+                const jsReason = ('js-decide lane=' + dec.lane + ' ' + (dec.decision || 'emit') +
+                  ' intent=' + num2(dec.features && dec.features.intentProb) +
+                  ' dense=' + num2(dec._denseTop) + ' margin=' + num2(dec._margin) +
+                  ' ' + (dec.reasonCodes || []).join(',')).slice(0, 160)
                 const act = {
                   schemaVersion: 1, namespace: 'dsh-auto-memory', kind: 'activation_request',
                   activationId: 'act_' + (obs.startsWith('obs_') ? obs.slice(8, 40) : 'jsdecide'),
-                  observationId: obs, workerEpoch: 'js-decide-pre-v1',
+                  observationId: obs, workerEpoch: 'js-decide-v1',
                   sessionId: session.sessionId || '', agentId: session.agentId || '',
                   workspaceKey: session.workspaceKey || '', scope: session.scope || 'Workspace',
                   contextVersion: cursor.contextVersion || 0, memoryIndexVersion: built.frame.index ? built.frame.index.memoryIndexVersion : '',
-                  threshold: { policyVersion: dec.features ? 'activation_policy_v2' : 'activation_policy_v2', score: (dec.features && dec.features.intentProb) || 0, threshold: 0.45, reason: ('js-decide lane=' + dec.lane + ' ' + (dec.reasonCodes || []).join(',')) },
+                  threshold: { policyVersion: dec.features ? 'activation_policy_v2' : 'activation_policy_v2', score: (dec.features && dec.features.intentProb) || 0, threshold: 0.45, reason: jsReason },
                   level: 'excerpt',
                   candidates: (function () {
                     // 2026-08-27 优化③:候选方案档位(balanced=3×40 / dense=6×20 / custom=自定义)
@@ -532,7 +562,39 @@ export function createContextHost(opts = {}) {
                     }
                   }
                 } catch (_) {}
+                // C5 闸门:记下本轮 query(激活请求本身不带 query 文本),供注入层判"是问为什么还是只要索引"
+                try {
+                  const qSid = String((act && act.sessionId) || '')
+                  const qRec = {
+                    at: Date.now(),
+                    sessionId: qSid,
+                    text: String(jsDecideQueryText || '').slice(0, 1200),
+                  }
+                  // 多工作区适配(2026-09-17):按会话分片。旧实现单槽无条件覆盖 ⇒ A 的 query 被 B 顶掉,
+                  // 读取侧因会话不匹配而退回 triggerText(语义降级)。分片后各会话各记一份。
+                  if (!engine._lastTierQueryBySession || typeof engine._lastTierQueryBySession.set !== 'function') {
+                    engine._lastTierQueryBySession = new Map()
+                  }
+                  engine._lastTierQueryBySession.set(qSid, qRec)
+                  if (engine._lastTierQueryBySession.size > 32) {
+                    const oldest = engine._lastTierQueryBySession.keys().next().value
+                    engine._lastTierQueryBySession.delete(oldest)
+                  }
+                  engine._lastTierQuery = qRec // 兼容投影(最近一次)
+                } catch (_) {}
                 engine._activationHost.offerExternalActivation(act)
+                // 命中投影补上 query(记录发生在 offer 内部;此处补字段,顺序确定)
+                // 多工作区适配(2026-09-17):分片条目与兼容投影**都要补**,否则按会话取到的投影缺 question。
+                try {
+                  const actSid = String((act && act.sessionId) || '')
+                  const qText = String(jsDecideQueryText || '').slice(0, 1200)
+                  const rec = engine._tierGateHitsBySession && typeof engine._tierGateHitsBySession.get === 'function'
+                    ? engine._tierGateHitsBySession.get(actSid) : null
+                  if (rec && String(rec.sessionId) === actSid) rec.question = qText
+                  if (engine._tierGateHits && String(engine._tierGateHits.sessionId) === actSid) {
+                    engine._tierGateHits.question = qText
+                  }
+                } catch (_) {}
               }).catch(() => {})
           } catch (_) {}
         }
@@ -723,6 +785,8 @@ export function createContextHost(opts = {}) {
       durableEventsOnDisk: evidenceRootExists() ? storeFor().loadEvents().events.length : 0,
       stats: { ...stats, bridge: { ...b.stats } },
       storeStats: store ? { ...store.stats } : null,
+      // C5/I7:索引未就绪降级(latest) —— 供面板/注入层解释"为什么这轮只有词法命中"
+      indexDegrade: lastIndexDegrade,
       recentDrops: volatileDrops.slice(-4),
     }
   }

package/lib/engine-identity.js

@@ -0,0 +1,149 @@
+/**
+ * 引擎身份（engine_identity_v1）—— P2「引擎隔离」的地基（V2-P2 卡 / 评审 §3.5）。
+ *
+ * 为什么需要它（权威依据）：
+ *   V2-P2 卡明确指出：单个 `PROVIDER_ID_INT8`（`python-setup.js:55`）**不足以**标识
+ *   模型内容 / tokenizer / 预处理；两层缓存若只凭 `chunkId` 或**裸输入哈希**读取，
+ *   **仍会串用两套向量**（e5 384 维与 bge-m3 1024 维混进同一次排序 = T2-9 判失败）。
+ *   因此身份必须够宽，至少覆盖：
+ *     模型与权重摘要 · tokenizer 版本 · 精度格式 · 维度 · 池化 · 归一化 · 输入处理版本。
+ *
+ * 本模块只做三件事（纯函数、零 IO、零依赖，便于宿主与测试共用）：
+ *   1) `computeEngineIdentityPre(desc)` —— 宽身份描述 → 稳定身份串 `engid_<32hex>`
+ *      （canonical 排序 JSON + sha256，同输入逐字节同输出；任一字段变化 → 身份必变）。
+ *   2) `aliasKeyPre(engineIdentity, chunkId)` —— 两级引用的**第一级**：
+ *      `engineIdentity + chunkId → alias`。记录变化导致未改块重新编号（chunkId 变）时，
+ *      只更新 alias，**不重新编码相同输入**（不改现有 chunkId 公式）。
+ *   3) `vectorKeyPre(engineIdentity, exactEncoderInput)` —— **第二级**：
+ *      `alias → hash(exactEncoderInput) → 向量对象`。相同输入且相同引擎 ⇒ 同一向量对象，
+ *      可直接复用；引擎不同 ⇒ vectorKey 必不同 ⇒ 不可能跨引擎串用（T2-9 的零成本实现）。
+ *
+ * 成本口径（评审 §3.5 采纳的措辞，不得写「成本为零」）：
+ *   **身份比较开销小；全量重建成本由本机承担。**
+ *
+ * UTF-8 无 BOM。
+ */
+import { createHash } from 'node:crypto'
+
+export const ENGINE_IDENTITY_VERSION = 'engine_identity_v1'
+
+/** 身份串前缀：有意与 corpus 的 `idx_` / L0 的 `l0idx_` 区分，避免三套版本语义混淆。 */
+export const ENGINE_IDENTITY_PREFIX = 'engid_'
+
+/** 身份必须覆盖的字段（缺一即身份不完整；缺失字段按空串参与哈希，不给"省略=通过"的口子）。 */
+export const ENGINE_IDENTITY_FIELDS = Object.freeze([
+  'provider',        // 通道/提供方标识（如 bge-m3-onnx-int8-v1 / js-e5-small-q8-v1）
+  'model',           // 模型名（如 bge-m3 / multilingual-e5-small）
+  'weightsDigest',   // 权重摘要（sha256 或廉价指纹；见 weightsDigestOfFilePre 的口径说明）
+  'tokenizer',       // tokenizer 版本/来源（如 xenova-bge-m3-fast / e5-small-tokenizer-v1）
+  'precision',       // 精度格式（int8 / q8 / fp32）
+  'dim',             // 向量维度（384 / 1024）
+  'pooling',         // 池化方式（cls / mean）
+  'normalized',      // 是否已归一化（true/false）
+  'inputVersion',    // 输入处理版本（前缀、截断、清洗等预处理口径）
+])
+
+const sha256Hex = (s) => createHash('sha256').update(String(s == null ? '' : s), 'utf8').digest('hex')
+
+/**
+ * 规范化身份描述：只保留白名单字段，值统一为字符串（数字/布尔 canonical 化），
+ * 键按固定顺序（ENGINE_IDENTITY_FIELDS，而非字母序）序列化 —— 顺序固定 = 哈希稳定。
+ */
+export function canonicalEngineDescPre(desc) {
+  const d = desc && typeof desc === 'object' ? desc : {}
+  const out = {}
+  for (const k of ENGINE_IDENTITY_FIELDS) {
+    const v = d[k]
+    if (v === null || v === undefined) { out[k] = ''; continue }
+    if (typeof v === 'boolean') { out[k] = v ? 'true' : 'false'; continue }
+    if (typeof v === 'number') { out[k] = Number.isFinite(v) ? String(v) : ''; continue }
+    out[k] = String(v)
+  }
+  return out
+}
+
+/**
+ * 宽身份计算：canonical 描述 → `engid_<first32hex(sha256)>`。
+ * 任一字段（含维度、精度、tokenizer、输入版本）变化 → 身份必变；同输入确定性。
+ */
+export function computeEngineIdentityPre(desc) {
+  const canon = canonicalEngineDescPre(desc)
+  return ENGINE_IDENTITY_PREFIX + sha256Hex(JSON.stringify(canon)).slice(0, 32)
+}
+
+/** 身份合法性：必须是本模块产出的前缀形态（防把任意字符串当身份塞进缓存）。 */
+export function isEngineIdentityPre(x) {
+  return typeof x === 'string' && /^engid_[0-9a-f]{32}$/.test(x)
+}
+
+/** 两个身份是否同一引擎。非法的身份一律视为不匹配（fail closed：宁可重建，不冒串用风险）。 */
+export function engineIdentityMatchesPre(a, b) {
+  if (!isEngineIdentityPre(a) || !isEngineIdentityPre(b)) return false
+  return a === b
+}
+
+/**
+ * 第一级引用：`engineIdentity + chunkId → aliasKey`。
+ * 用途：记录内容变化 → memoryId/recordDigest 变化 → chunkId 变；此键随引擎与 chunkId 走，
+ * 是"记录 → 向量"的可更新指针（记录重编号时只改这一层）。
+ */
+export function aliasKeyPre(engineIdentity, chunkId) {
+  return String(engineIdentity || '') + '|' + String(chunkId == null ? '' : chunkId)
+}
+
+/**
+ * 第二级引用：`engineIdentity + exactEncoderInput → vectorKey`。
+ * exactEncoderInput = **真正送进编码器的文本**（含引擎内部前缀之后的形态；调用方负责给出
+ * 与编码器输入一致的字符串）。相同引擎 + 相同输入 ⇒ 相同 vectorKey ⇒ 复用向量对象。
+ * 该键不含 chunkId，因此**块重新编号不会导致重复编码**（T2-2 的核心）。
+ */
+export function vectorKeyPre(engineIdentity, exactEncoderInput) {
+  return String(engineIdentity || '') + '|' + sha256Hex(exactEncoderInput)
+}
+
+/**
+ * 权重摘要的**廉价指纹**（性能口径，必须如实标注）：
+ * 对 2GB 级 onnx 做全量 sha256 代价过高，这里用 `size:mtimeMs:文件名` 的 sha256 作为
+ * **权重变更指纹**（同一份权重稳定、文件被替换/重下必变）。
+ * 说明：这是**指纹（fingerprint）而非内容摘要（digest）**；要真摘要需在切换时一次性计算
+ * 并落盘缓存（P4 若需要再补），本阶段不引入 2GB 级读盘开销。
+ */
+export function weightsDigestOfFilePre(stat, name) {
+  const size = Number(stat && stat.size) || 0
+  const mtime = Number(stat && (stat.mtimeMs != null ? stat.mtimeMs : stat.mtime)) || 0
+  return 'fp_' + sha256Hex(size + ':' + mtime + ':' + String(name == null ? '' : name)).slice(0, 32)
+}
+
+/** 端侧 JS 引擎（e5-small q8，384 维已归一化）的规范身份描述。 */
+export const JS_E5_IDENTITY_DESC_V1 = Object.freeze({
+  provider: 'js-e5-small-q8-v1',
+  model: 'multilingual-e5-small',
+  weightsDigest: 'manifest-e5-small-q8-v1', // 端侧资产清单版本；模型文件摘要由下载清单锁定
+  tokenizer: 'e5-small-tokenizer-v1',
+  precision: 'q8',
+  dim: 384,
+  pooling: 'mean',
+  normalized: true,
+  inputVersion: 'e5-passage-prefix-v1', // 引擎内部加 `passage: ` 前缀（见 semantic-js.js:351 注释）
+})
+
+/** Python 引擎（bge-m3 onnx int8，1024 维）的身份描述构造器（weightsDigest 由调用方给指纹）。 */
+export function pyBgeM3IdentityDescPre(weightsDigest) {
+  return {
+    provider: 'bge-m3-onnx-int8-v1',
+    model: 'bge-m3',
+    weightsDigest: weightsDigest || '',
+    tokenizer: 'xenova-bge-m3-fast',
+    precision: 'int8',
+    dim: 1024,
+    pooling: 'cls',
+    normalized: true,
+    inputVersion: 'bge-m3-raw-v1',
+  }
+}
+
+/** 供诊断/测试的最小投影（不泄内容：只有身份串与字段读数）。 */
+export function describeEngineIdentityPre(desc) {
+  const canon = canonicalEngineDescPre(desc)
+  return { identity: computeEngineIdentityPre(desc), fields: canon, version: ENGINE_IDENTITY_VERSION }
+}

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,7 +100,7 @@ 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)
   }
 
@@ -118,7 +119,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 +142,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,高频优先)。 */

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)))
 }
 
 /**

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

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