@a9i5k4/dsh-auto-memory 3.1.4 → 3.1.6

package/lib/procedure-store.js

@@ -61,28 +61,43 @@ import { createHash } from 'node:crypto'
 
 // ========== 冻结常量 ==========
 
-export const PROCEDURE_POLICY_VERSION = 'procedure_store_v1'
-export const PROCEDURE_ID_PREFIX = 'proc_'
-export const PROCEDURE_ID_RE = /^proc_[0-9a-f]{32}$/
+export const PROCEDURE_POLICY_VERSION = 'procedure_store_pre_v1'
+export const PROCEDURE_ID_PREFIX = 'proc_pre_'
+export const PROCEDURE_ID_RE = /^proc_pre_[0-9a-f]{32}$/
 
 /** 阶段枚举(M-04 元代码)。P2-3:移除死状态 'candidate' —— 全仓无写入点,
  *  observe 只产 observed、promote 直接 observed→validated(两态跳变)。 */
-export const PROCEDURE_STAGES_V1 = Object.freeze(['observed', 'validated', 'active', 'deprecated'])
+export const PROCEDURE_STAGES_PRE_V1 = Object.freeze(['observed', 'validated', 'active', 'deprecated'])
 
 /** 自动归档老化(Hermes curator 借鉴,2026-08-28):active 技能 lastUsedAt 超过
- *  PROCEDURE_ARCHIVE_AFTER_DAYS_V1 天未使用且未 pinned → 自动 deprecated
+ *  PROCEDURE_ARCHIVE_AFTER_DAYS_PRE_V1 天未使用且未 pinned → 自动 deprecated
  *  (reason=auto-archive-inactive;deprecated 可恢复,永不物理删除)。
  *  observed/validated 不老化——它们由晋升门槛时间控(P2-3 后已无 candidate 态)。 */
-export const PROCEDURE_ARCHIVE_AFTER_DAYS_V1 = 90
+export const PROCEDURE_ARCHIVE_AFTER_DAYS_PRE_V1 = 90
 
 /** 风险等级枚举。 */
-export const PROCEDURE_RISKS_V1 = Object.freeze(['low', 'medium', 'high'])
+export const PROCEDURE_RISKS_PRE_V1 = Object.freeze(['low', 'medium', 'high'])
 
 /** 激活等级(M6 六级契约)。 */
-export const PROCEDURE_LEVELS_V1 = Object.freeze(['index', 'hint', 'excerpt', 'checklist', 'resource', 'full'])
+export const PROCEDURE_LEVELS_PRE_V1 = Object.freeze(['index', 'hint', 'excerpt', 'checklist', 'resource', 'full'])
+
+/**
+ * ★M8-B（2026-09-23 用户拍板）：记忆库作用域枚举 —— 工作区库 / 通用库。
+ *
+ * 物理落点由 IO 层按 `scope` 分派（本模块只负责**携带与校验**该字段，不碰路径）：
+ *   · `workspace` → `<workspaces>/<wsKey>/hub-pre/procedures.json`（工作区库，新增）
+ *   · `global`    → `<dshHome>/memory/hub-pre/procedures.json`（通用库，既有 55 条所在）
+ *
+ * **缺省语义**：字段缺失一律按 `global` 解释 —— 老数据本就全在通用库里，按此缺省即可零迁移；
+ * 要进工作区库必须**显式声明**，否则 IO 层 fail-soft 落通用库（绝不丢条目）。
+ */
+export const PROCEDURE_SCOPES_PRE_V1 = Object.freeze(['workspace', 'global'])
+
+/** 缺省作用域常量（供 IO 层与调用方共用，避免各写一份字面量）。 */
+export const PROCEDURE_DEFAULT_SCOPE_PRE_V1 = 'global'
 
 /** 晋升门槛(可调参数,默认值来自 M-04 元代码): 跨会话多样性≥3, 成功≥2。 */
-export const PROCEDURE_DEFAULT_GATES_V1 = Object.freeze({
+export const PROCEDURE_DEFAULT_GATES_PRE_V1 = Object.freeze({
   minSessionDiversity: 3,
   minSuccessCount: 2,
   maxCorrectionRate: 0.3,   // correction 占总证据比例上限
@@ -91,18 +106,18 @@ export const PROCEDURE_DEFAULT_GATES_V1 = Object.freeze({
 })
 
 /** 一次成功或三次重复都不足以证明可靠 → 需要的最小成功数(元代码铁律)。 */
-export const PROCEDURE_MIN_SUCCESS_V1 = 2
+export const PROCEDURE_MIN_SUCCESS_PRE_V1 = 2
 
 /** active 后可注入的默认 level(渐进激活;高风险降级为 hint)。 */
-export const PROCEDURE_ACTIVE_LEVEL_V1 = 'checklist'
+export const PROCEDURE_ACTIVE_LEVEL_PRE_V1 = 'checklist'
 
 /** procedure 校验(固化/读回)。 */
 export function validateProcedurePre(p) {
   const q = []
   if (!p || typeof p !== 'object' || Array.isArray(p)) return { ok: false, reason: 'not-object' }
   if (typeof p.procedureId !== 'string' || !PROCEDURE_ID_RE.test(p.procedureId)) q.push('procedureId')
-  if (!PROCEDURE_STAGES_V1.includes(p.stage)) q.push('stage')
-  if (!PROCEDURE_RISKS_V1.includes(p.riskLevel)) q.push('riskLevel')
+  if (!PROCEDURE_STAGES_PRE_V1.includes(p.stage)) q.push('stage')
+  if (!PROCEDURE_RISKS_PRE_V1.includes(p.riskLevel)) q.push('riskLevel')
   if (typeof p.title !== 'string' || !p.title.trim()) q.push('title')
   if (!Array.isArray(p.sourceMemoryIds)) q.push('sourceMemoryIds')
   if (!Array.isArray(p.sourceEpisodes)) q.push('sourceEpisodes')
@@ -118,6 +133,11 @@ export function validateProcedurePre(p) {
   if (p.lastUsedAt !== undefined && (typeof p.lastUsedAt !== 'number' || !Number.isFinite(p.lastUsedAt))) q.push('lastUsedAt')
   if (p.pinned !== undefined && typeof p.pinned !== 'boolean') q.push('pinned')
   if (p.origin !== undefined && !['agent', 'user'].includes(p.origin)) q.push('origin')
+  // ★M8-B（2026-09-23）：库归属与来源身份（均为可选，向后兼容旧快照）。
+  //   判据一律**白名单式**（不在枚举内即拒）—— 仓内既有纪律：不得用负向类型判断实现白名单门。
+  if (p.scope !== undefined && !PROCEDURE_SCOPES_PRE_V1.includes(p.scope)) q.push('scope')
+  if (p.workspaceRef !== undefined && typeof p.workspaceRef !== 'string') q.push('workspaceRef')
+  if (p.addedBy !== undefined && typeof p.addedBy !== 'string') q.push('addedBy')
   // ★A-6(2026-09-21):evidence 形状校验。此前清单里**没有 evidence** ⇒
   //   ① 缺键时 promote() 的 `ev.seen + ev.read + …` 得 NaN,`NaN > cap` 为 false **静默放行**;
   //   ② evidence 整个缺失时 addEvidence 抛 TypeError,被宿主 lib/index.js:7644 空 catch 吞掉。
@@ -141,7 +161,7 @@ export function validateProcedureCandidatePre(c) {
   const p = []
   if (!c || typeof c !== 'object' || Array.isArray(c)) return { ok: false, reason: 'not-object' }
   if (typeof c.title !== 'string' || !c.title.trim()) p.push('title')
-  if (!PROCEDURE_RISKS_V1.includes(c.riskLevel || 'low')) p.push('riskLevel')
+  if (!PROCEDURE_RISKS_PRE_V1.includes(c.riskLevel || 'low')) p.push('riskLevel')
   if (!Array.isArray(c.steps) || !c.steps.length) p.push('steps')
   if (c.successCriteria !== undefined && !Array.isArray(c.successCriteria)) p.push('successCriteria')
   if (c.sourceMemoryIds !== undefined && !Array.isArray(c.sourceMemoryIds)) p.push('sourceMemoryIds')
@@ -150,6 +170,10 @@ export function validateProcedureCandidatePre(c) {
   if (c.checks !== undefined && !Array.isArray(c.checks)) p.push('checks')
   if (c.rollback !== undefined && !Array.isArray(c.rollback)) p.push('rollback')
   if (c.observationOnly !== undefined && typeof c.observationOnly !== 'boolean') p.push('observationOnly')
+  // ★M8-B：候选也接受库归属与来源身份（校验口径与 validateProcedurePre 一致）。
+  if (c.scope !== undefined && !PROCEDURE_SCOPES_PRE_V1.includes(c.scope)) p.push('scope')
+  if (c.workspaceRef !== undefined && typeof c.workspaceRef !== 'string') p.push('workspaceRef')
+  if (c.addedBy !== undefined && typeof c.addedBy !== 'string') p.push('addedBy')
   if (p.length) return { ok: false, reason: 'invalid:' + p.join(',') }
   return { ok: true, candidate: c }
 }
@@ -168,8 +192,8 @@ export function createProcedureStorePre(opts = {}) {
   const approveFn = typeof opts.approve === 'function' ? opts.approve : null
   // 2026-08-30:gates 保留调用方对象引用(支持 getter 活读配置);缺省才用冻结默认。
   // 注意:不可 Object.assign 展开——会立即求值 getter 并冻结挂载时的配置快照。
-  const gates = opts.gates || PROCEDURE_DEFAULT_GATES_V1
-  const activeLevel = opts.activeLevel || PROCEDURE_ACTIVE_LEVEL_V1
+  const gates = opts.gates || PROCEDURE_DEFAULT_GATES_PRE_V1
+  const activeLevel = opts.activeLevel || PROCEDURE_ACTIVE_LEVEL_PRE_V1
 
   let procedures = []      // 全部 procedure(各 stage)
   let disposed = false
@@ -197,7 +221,7 @@ export function createProcedureStorePre(opts = {}) {
   }
 
   function defaultProcedureId(title, createdAt) {
-    const h = createHash('sha256').update(['procedure-v1', String(title), String(createdAt)].join('\u0000')).digest('hex')
+    const h = createHash('sha256').update(['procedure-pre-v1', String(title), String(createdAt)].join('\u0000')).digest('hex')
     return PROCEDURE_ID_PREFIX + h.slice(0, 32)
   }
 
@@ -241,6 +265,11 @@ export function createProcedureStorePre(opts = {}) {
       lastUsedAt: now,
       pinned: false,
       origin: c.origin === 'user' ? 'user' : 'agent',
+      // ★M8-B（2026-09-23）：库归属 + 来源身份。缺省 `global` = 留在通用库，
+      //   与旧行为逐字节一致；要求进工作区库的调用方必须显式给 scope+workspaceRef。
+      scope: PROCEDURE_SCOPES_PRE_V1.includes(c.scope) ? c.scope : PROCEDURE_DEFAULT_SCOPE_PRE_V1,
+      workspaceRef: typeof c.workspaceRef === 'string' ? c.workspaceRef : '',
+      addedBy: typeof c.addedBy === 'string' ? c.addedBy : '',
       // issue #30:纯 episode 观察行显式打标 —— 它没有 successCriteria,永远不该晋升,
       // 也不该与富候选互相污染(此前无标记,只能靠 title 撞车后丢字段)。
       ...(isObservationOnlyPre(c) ? { observationOnly: true } : {}),
@@ -308,7 +337,7 @@ export function createProcedureStorePre(opts = {}) {
    *  只归档不删除;返回变更计数。 */
   function applyAutomaticTransitions(nowTs) {
     const now = Number.isFinite(nowTs) ? nowTs : nowFn()
-    const cutoff = now - PROCEDURE_ARCHIVE_AFTER_DAYS_V1 * 86400000
+    const cutoff = now - PROCEDURE_ARCHIVE_AFTER_DAYS_PRE_V1 * 86400000
     const counts = { checked: 0, archived: 0 }
     for (const p of procedures) {
       counts.checked++
@@ -413,7 +442,7 @@ export function createProcedureStorePre(opts = {}) {
    * ⇒ 只读面必须走本函数（用户 2026-09-18 冻结纪律）。
    *
    * ⚠️ 维护约定：改 `promote()` 的门限时**必须同步改这里**，否则前端会展示过时的判据。
-   * 两者的一致性由测试 `smoke-test-r2-promotion-pre.mjs` 用变异兜底。
+   * 两者的一致性由测试 `smoke-test-r2-promotion.mjs` 用变异兜底。
    *
    * @returns {{ok:boolean, decision?:string, reasonCodes?:string[], detail?:object}}
    */
@@ -457,11 +486,40 @@ export function createProcedureStorePre(opts = {}) {
     return { ok: true, decision: 'promote', reasonCodes: reason, detail: { diversity, successCount } }
   }
 
+  /**
+   * ★A-9b（2026-09-23）：补判「被统计门 early-return 遮住」的结构门 —— 供只读越权投影使用。
+   *
+   * 与 `promote()` **逐条同源**（同字段、同 gates 常量、同判定式），只是**不提前 return**：
+   * 把统计门之后**所有**会拦人的结构门都取出来。取码顺序 = `promote()` 里的真实顺序
+   * （correction-rate → has-correction → no-success-criteria → 高风险），故
+   * `statCodes.concat(hidden)` 与「授权后走 promote()」吐出的原因码序列一致。
+   *
+   * ⚠️ 维护约定：`promote()` 统计门之后每加/改一道结构门，本函数必须同步（否则界面会
+   * 重新长出「点了没反应」的强制晋升按钮 —— 那正是 A-9b 要根治的事故）。
+   * 纯读，不写盘、不改状态、不动统计。
+   *
+   * @param {object} p 条目
+   * @param {object} g 门限（gates）
+   * @returns {string[]} 被遮结构门的原因码（无则空数组）
+   */
+  function hiddenStructuralCodesPre(p, g) {
+    const out = []
+    const ev = (p && p.evidence) || {}
+    const num = (v) => Number(v) || 0
+    const total = num(ev.seen) + num(ev.read) + num(ev.cite) + num(ev.reuse) + num(ev.success) + num(ev.correction)
+    const corrRate = total > 0 ? num(ev.correction) / total : 0
+    if (corrRate > g.maxCorrectionRate) out.push('correction-rate-' + corrRate.toFixed(2))
+    if (g.maxContradictions === 0 && num(ev.correction) > 0) out.push('has-correction')
+    if (!p || !p.successCriteria || !p.successCriteria.length) out.push('no-success-criteria')
+    if (p && p.requiresApproval && !p.approved) out.push('high-risk-awaiting-approval')
+    return out
+  }
+
   /**
    * ★A/B（2026-09-22）：**人工可越权性**只读投影 —— 回答「这道 keep 人能不能强制越过」。
    *
    * 为什么单独一个函数、而不是给 evaluatePromotion 加参数：
-   *   · `smoke-test-r2-promotion-pre.mjs` 用**字面正则**锁住了 `evaluatePromotion(procedureId)` 的签名，
+   *   · `smoke-test-r2-promotion.mjs` 用**字面正则**锁住了 `evaluatePromotion(procedureId)` 的签名，
    *     并用**源码切片**比对它与 `promote()` 的 reason.push 序列；动它的签名或函数体会同时打红两条守卫。
    *   · 更要紧的是「不重复实现门限」：本函数**不重写任何一道门**，而是复用 evaluatePromotion 的结论，
    *     只判断「拦它的原因码里是否**只有**那两道统计门」。
@@ -472,7 +530,23 @@ export function createProcedureStorePre(opts = {}) {
    *     no-success-criteria / high-risk-awaiting-approval）**授权也拦**
    *     ⇒ 只要原因码里出现其中任何一个，就**不可越权**（界面上不该给强制按钮）。
    *
-   * 纯只读：只调 evaluatePromotion，不写盘、不改状态、不动统计。异常一律 fail-soft 返回不可越权。
+   * ★A-9b（2026-09-23 用户拍板「按推荐方案全修」）：**必须补查被提前 return 遮住的结构门**。
+   *
+   * 事故（有代码证据）：`evaluatePromotion` 的门限顺序是 diversity → success → correction-rate →
+   * has-correction → no-success-criteria → **高风险**，前一道不过就 early-return。于是
+   * 「证据不足 + 高风险未批准」的条目只吐出 `['diversity-below-3']` ⇒ 旧判据（"码全是统计门"）
+   * 得 `overridable:true` ⇒ 界面渲染「强制晋升」按钮；点下去 `promote()` 跳过统计门后**撞上高风险门**
+   * 返回 `ask`，用户所见 `force-promote: ask (user-authorized, high-risk-awaiting-approval)`
+   * 正是这条链 —— 一个点了没反应（没晋升）的假通道。
+   *
+   * 修法（**不动 evaluatePromotion 的签名/函数体/门限顺序** —— r2 用字面正则锁签名、
+   * 用源码切片锁顺序）：在只读投影这一层，把「统计门之后仍会拦人的结构门」**独立补判一次**。
+   * 判据与 `promote()` 的对应门**逐条同源**（同一字段、同一 gates 常量），只是**取码顺序按
+   * promote() 真实顺序**，故本函数输出的 codes 序列与「授权后的 promote()」一致。
+   *
+   * ⚠️ 维护约定：改 `promote()` 统计门之后的任一结构门，必须同步改 `hiddenStructuralCodesPre`。
+   *
+   * 纯只读：只调 evaluatePromotion + 读条目字段，不写盘、不改状态、不动统计。异常一律 fail-soft。
    *
    * @param {string} procedureId
    * @returns {{ok:boolean, decision?:string, overridable:boolean, reasonCodes?:string[], gateKind?:string}}
@@ -493,13 +567,23 @@ export function createProcedureStorePre(opts = {}) {
       const codes = Array.isArray(view.reasonCodes) ? view.reasonCodes : []
       const isStat = (c) => /^diversity-below-/.test(c) || /^success-below-/.test(c)
       const stat = codes.length > 0 && codes.every(isStat)
-      return {
-        ok: true,
-        decision: 'keep',
-        overridable: stat,
-        gateKind: stat ? 'statistical' : 'structural',
-        reasonCodes: codes,
+      if (!stat) {
+        return { ok: true, decision: 'keep', overridable: false, gateKind: 'structural', reasonCodes: codes }
+      }
+      // ★A-9b：码全是统计门，但这些码是**提前 return 的结果**、不完整 —— 补查被遮结构门。
+      const p = procedures.find((x) => x.procedureId === procedureId)
+      if (!p) return { ok: false, overridable: false, gateKind: 'unknown' }
+      const hidden = hiddenStructuralCodesPre(p, gates)
+      if (hidden.length) {
+        return {
+          ok: true,
+          decision: 'keep',
+          overridable: false,
+          gateKind: 'structural',
+          reasonCodes: codes.concat(hidden),
+        }
       }
+      return { ok: true, decision: 'keep', overridable: true, gateKind: 'statistical', reasonCodes: codes }
     } catch (_) {
       return { ok: false, overridable: false, gateKind: 'unknown' }
     }
@@ -644,7 +728,7 @@ export function createProcedureStorePre(opts = {}) {
   // ---- 持久化 ----
   function snapshot() {
     return {
-      schemaVersion: 1, namespace: 'dsh-auto-memory', policyVersion: PROCEDURE_POLICY_VERSION,
+      schemaVersion: 1, namespace: 'dsh-auto-memory-pre', policyVersion: PROCEDURE_POLICY_VERSION,
       savedAt: nowFn(),
       procedures: procedures.map((p) => ({ ...p, _sessions: p._sessions ? [...p._sessions] : undefined, evidence: { ...p.evidence } })),
     }
@@ -666,6 +750,11 @@ export function createProcedureStorePre(opts = {}) {
       }
       // issue #30:旧快照里没有 observationOnly 字段,恢复时按同一判据补齐
       // (纯增量元数据迁移:不改身份/文本/风险/证据/阶段)。
+      // ★M8-B：旧快照没有库归属字段 —— 恢复时按缺省语义补齐为「通用库」，
+      //   使下游 IO 分派与前端分组都有确定值（纯增量元数据迁移，不改身份/文本/证据/阶段）。
+      if (v.procedure.scope === undefined) v.procedure.scope = PROCEDURE_DEFAULT_SCOPE_PRE_V1
+      if (v.procedure.workspaceRef === undefined) v.procedure.workspaceRef = ''
+      if (v.procedure.addedBy === undefined) v.procedure.addedBy = ''
       procedures.push(normalizeProcedureObservationPre(v.procedure))
     }
     // ★B-1(2026-09-21):stats.approved 是本轮新增计数,旧快照(以及本模块自己的快照 ——

package/lib/python-setup.js

@@ -1,3 +1,4 @@
+import { memoryDir } from './datadir.js'
 /**
  * M7.6 Python 一键向导(host 半):#16-#20 配套——把 C3 进阶档从"开发机可达"变成"爱好者可达"。
  *
@@ -53,8 +54,8 @@ const PIP_DEPS_GPU_EXTRA = ['onnxruntime-gpu']
  *  历史上探针多要一个 torch,而 PIP_DEPS_CPU 从不装 torch → depsOk 恒 false,"全部就绪"永不出现。 */
 const DEPS_PROBE = 'import transformers, onnxruntime, numpy; print("deps-ok")'
 
-/** worker 侧 load_embedder 的档位名(m7_embedding_v1.PROVIDER_REAL_INT8);发布构建会把 -v1 折成 -v1。 */
-const PROVIDER_ID_INT8 = 'bge-m3-onnx-int8-v1'
+/** worker 侧 load_embedder 的档位名(m7_embedding_pre_v1.PROVIDER_REAL_INT8);发布构建会把 -pre-v1 折成 -v1。 */
+const PROVIDER_ID_INT8 = 'bge-m3-onnx-int8-pre-v1'
 /** dense 维度(BGE-M3 = 1024),写进 embedding-config.json 的 dimension。 */
 const EMBED_DIMENSION = 1024
 
@@ -101,10 +102,10 @@ export function createPythonSetupPre(opts = {}) {
   }
 
   // ---------- 引擎侧 embedding-config.json(D1/D2:向导产物必须落在 worker 真正读取的位置与键上) ----------
-  /** worker 读 <dsh-home>/memory/semantic/embedding-config.json(见 worker_semantic_v1.load_embedding_config_from_env);
-   *  发布构建会把 `semantic` 折成 `semantic`,故这里写带 -pre 的规范名。
+  /** worker 读 <dsh-home>/memory/semantic-pre/embedding-config.json(见 worker_semantic_pre_v1.load_embedding_config_from_env);
+   *  发布构建会把 `semantic-pre` 折成 `semantic`,故这里写带 -pre 的规范名。
    *  历史缺陷:向导曾写 <dsh-home>/memory/semantic/(缺 -pre),pre 线 worker 从不读该路径 → 装完即"找不到配置"。 */
-  const embeddingConfigPath = () => path.join(dshHomeOf(), 'memory', 'semantic', 'embedding-config.json')
+  const embeddingConfigPath = () => path.join(memoryDir('semantic', dshHomeOf), 'embedding-config.json')
 
   /** read-modify-write:只覆盖本次传入的键,保留引擎运行期自管的 search/activationPolicy/activationEmitMode 等。 */
   async function patchEmbeddingConfig(patch) {

package/lib/python-sidecar-client.js

@@ -28,18 +28,18 @@ import { randomBytes } from 'node:crypto'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import {
-  validateTransportFramePre, makeRequestFramePre, RESPONSE_TYPE_FOR_V1,
-  M7_TRANSPORT_BUDGET_V1, PY_FRAME_TYPES_V1,
+  validateTransportFramePre, makeRequestFramePre, RESPONSE_TYPE_FOR_PRE_V1,
+  M7_TRANSPORT_BUDGET_PRE_V1, PY_FRAME_TYPES_PRE_V1,
 } from './m7-wire.js'
 
-const B = M7_TRANSPORT_BUDGET_V1
+const B = M7_TRANSPORT_BUDGET_PRE_V1
 
 /**
- * 看门狗/诊断策略(**客户端本地策略量**,刻意不放进 M7_TRANSPORT_BUDGET_V1)。
+ * 看门狗/诊断策略(**客户端本地策略量**,刻意不放进 M7_TRANSPORT_BUDGET_PRE_V1)。
  * 理由有二:①传输预算按契约冻结、变更须升协议版本,而「多久判挂死」是客户端自愈策略、不是 wire 契约;
  * ②wire 文件同期另有 PR(#122/#124)在改,本任务不去碰它以避开写域冲突。
  */
-const SIDECAR_WATCHDOG_V1 = Object.freeze({
+const SIDECAR_WATCHDOG_PRE_V1 = Object.freeze({
   stallThreshold: 3,      // 连续超时(心跳缺失)达此数 ⇒ 判定挂死,看门狗击杀旧进程
   stderrTailChars: 4096,  // stderr 环形尾部保留长度(既有语义,原为字面量 4096)
   diagRingCapacity: 16,   // diag 环形缓冲条数(超出丢最旧)
@@ -48,7 +48,7 @@ const SIDECAR_WATCHDOG_V1 = Object.freeze({
 })
 
 /** 退出归因优先级:高优先级不被低优先级覆盖。 */
-const EXIT_KIND_RANK_V1 = Object.freeze({ crash: 0, restart: 1, dispose: 1, fatal: 2, watchdog: 3 })
+const EXIT_KIND_RANK_PRE_V1 = Object.freeze({ crash: 0, restart: 1, dispose: 1, fatal: 2, watchdog: 3 })
 
 /**
  * ★ #107 熔断清零口径:只有「终态成功」才把累计失败清零。
@@ -57,12 +57,12 @@ const EXIT_KIND_RANK_V1 = Object.freeze({ crash: 0, restart: 1, dispose: 1, fata
  * 成功就把累计失败抹平,峰值恒 1、阈值 3(breakerFailureThreshold)永不达,熔断形同虚设。
  * health / context_push / index_sync_commit 才是各自工作单元的终态应答。
  */
-const TERMINAL_SUCCESS_TYPES_V1 = new Set(['health', 'context_push', 'index_sync_commit'])
+const TERMINAL_SUCCESS_TYPES_PRE_V1 = new Set(['health', 'context_push', 'index_sync_commit'])
 
-/** 捆绑 fake worker 的默认绝对路径(python/worker_v1.py)。 */
+/** 捆绑 fake worker 的默认绝对路径(python/worker_pre_v1.py)。 */
 export function defaultWorkerScriptPathPre() {
   try {
-    return path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'python', 'worker_v1.py')
+    return path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'python', 'worker_pre_v1.py')
   } catch (_) { return '' }
 }
 
@@ -141,9 +141,9 @@ export function createPythonSidecarClientPre(opts = {}) {
 
   /** 有界 diag 环形缓冲:落一条**给人看**的中文诊断;opts.onDiag 在场时同步外发一份。 */
   function pushDiag(level, text) {
-    const rec = { at: Date.now(), level, sidecar: 'python-sidecar-pre', generation, message: String(text) }
+    const rec = { at: Date.now(), level, sidecar: 'python-sidecar', generation, message: String(text) }
     diagRing.push(rec)
-    while (diagRing.length > Math.max(1, Number(opt('diagRingCapacity', SIDECAR_WATCHDOG_V1.diagRingCapacity)))) diagRing.shift()
+    while (diagRing.length > Math.max(1, Number(opt('diagRingCapacity', SIDECAR_WATCHDOG_PRE_V1.diagRingCapacity)))) diagRing.shift()
     const sink = resolveOpt('onDiag')
     if (typeof sink === 'function') { try { sink({ at: rec.at, level: rec.level, generation, message: rec.message }) } catch (_) {} }
     return rec
@@ -161,8 +161,8 @@ export function createPythonSidecarClientPre(opts = {}) {
     // 刻意不用正则字面量:本仓所有 .js 均为 CRLF,避免任何转义歧义。
     const all = src.split(NL).map((l) => (l.endsWith(CR) ? l.slice(0, -1) : l))
     while (all.length && all[all.length - 1] === '') all.pop()
-    const maxLines = Math.max(1, Number(opt('diagTailLines', SIDECAR_WATCHDOG_V1.diagTailLines)))
-    const maxChars = Math.max(1, Number(opt('diagTailChars', SIDECAR_WATCHDOG_V1.diagTailChars)))
+    const maxLines = Math.max(1, Number(opt('diagTailLines', SIDECAR_WATCHDOG_PRE_V1.diagTailLines)))
+    const maxChars = Math.max(1, Number(opt('diagTailChars', SIDECAR_WATCHDOG_PRE_V1.diagTailChars)))
     const kept = all.slice(-maxLines)
     let truncated = kept.length < all.length
     let text = kept.join(NL)
@@ -187,7 +187,7 @@ export function createPythonSidecarClientPre(opts = {}) {
   function markExitKind(gen, kind) {
     if (!gen) return
     const cur = exitKindByGen.get(gen) || 'crash'
-    if ((EXIT_KIND_RANK_V1[kind] || 0) < (EXIT_KIND_RANK_V1[cur] || 0)) return
+    if ((EXIT_KIND_RANK_PRE_V1[kind] || 0) < (EXIT_KIND_RANK_PRE_V1[cur] || 0)) return
     exitKindByGen.set(gen, kind)
     while (exitKindByGen.size > 64) exitKindByGen.delete(exitKindByGen.keys().next().value)
   }
@@ -247,7 +247,7 @@ export function createPythonSidecarClientPre(opts = {}) {
     stats.watchdog.lastReason = trigger
     stats.watchdog.lastAt = Date.now()
     stats.watchdog.lastDetail = detail || null
-    const thr = Math.max(1, Number(opt('watchdogStallThreshold', SIDECAR_WATCHDOG_V1.stallThreshold)))
+    const thr = Math.max(1, Number(opt('watchdogStallThreshold', SIDECAR_WATCHDOG_PRE_V1.stallThreshold)))
     pushDiag('error', '第 ' + generation + ' 代 Python 语义侧车连续 ' + thr + ' 次心跳缺失(' + trigger + ')⇒ 看门狗主动击杀旧进程;下次请求将重生新进程(新 epoch),未经确认的旧 in-flight 请求按 crashed 结算。')
     logExitDiag(generation, 'watchdog', humanExitNote(generation, 'watchdog', null, null))
     try { proc.stdin.destroy() } catch (_) {}
@@ -258,7 +258,7 @@ export function createPythonSidecarClientPre(opts = {}) {
   /** 心跳缺失证据:只把「超时」算挂死(abort 是调用方主动取消,不构成挂死证据)。 */
   function noteStall(type, requestId, timeoutMs) {
     consecutiveTimeouts++
-    const thr = Math.max(1, Number(opt('watchdogStallThreshold', SIDECAR_WATCHDOG_V1.stallThreshold)))
+    const thr = Math.max(1, Number(opt('watchdogStallThreshold', SIDECAR_WATCHDOG_PRE_V1.stallThreshold)))
     if (consecutiveTimeouts < thr) return
     disarmHungChild('连续超时', { type: String(type), requestId: String(requestId), timeoutMs: Number(timeoutMs), consecutiveTimeouts })
   }
@@ -305,7 +305,7 @@ export function createPythonSidecarClientPre(opts = {}) {
     const scriptPath = String(resolveOpt('scriptPath') || defaultWorkerScriptPathPre())
     const command = String(resolveOpt('command') || 'python')
     const dshHome = String(resolveOpt('dshHome') || '')
-    epoch = 'wk_' + randomBytes(16).toString('hex')
+    epoch = 'wk_pre_' + randomBytes(16).toString('hex')
     const args = [scriptPath, '--expect-epoch', epoch]
     if (dshHome) args.push('--dsh-home', dshHome)
     let proc
@@ -327,7 +327,7 @@ export function createPythonSidecarClientPre(opts = {}) {
     proc.stdout.on('data', (chunk) => { try { feed(chunk) } catch (_) { fatal('protocol') } })
     proc.stderr.on('data', (chunk) => {
       stderrTail = (stderrTail + chunk.toString('utf8'))
-        .slice(-Math.max(256, Number(opt('stderrTailChars', SIDECAR_WATCHDOG_V1.stderrTailChars))))
+        .slice(-Math.max(256, Number(opt('stderrTailChars', SIDECAR_WATCHDOG_PRE_V1.stderrTailChars))))
     })
     proc.on('error', () => {
       // spawn 失败(ENOENT 等):结构化失败,不计崩溃重启
@@ -406,7 +406,7 @@ export function createPythonSidecarClientPre(opts = {}) {
     //   （未启动 / `exit` 事件已置 null 但旧 stdio 尚未排空 / restart 后到新 spawn 之间），
     //   而 `activation_request` 上游 `context-host` **无二次校验**（同 activationId 有 dedup 兜底，
     //   但**新 activationId 可穿透**）⇒ 幽灵激活。
-    //   新判据：**epoch 为空 ⇒ 一律丢弃**。理由：spawn 时同步赋 epoch（:91 `epoch = 'wk_' + …` 在
+    //   新判据：**epoch 为空 ⇒ 一律丢弃**。理由：spawn 时同步赋 epoch（:91 `epoch = 'wk_pre_' + …` 在
     //   `spawn()` **之前**执行），出站帧也就带上了 epoch；对端 worker 以 `--expect-epoch` 自证身份后才回帧
     //   ⇒ **正常路径不存在"帧先于 epoch"**，丢弃不会误伤任何合法流量。
     if (!epoch || frame.workerEpoch !== epoch) { stats.dropped.staleEpoch++; return }
@@ -447,7 +447,7 @@ export function createPythonSidecarClientPre(opts = {}) {
       // ★ #107 熔断清零口径:只有「终态成功」清零累计失败;段内进度帧(index_sync_begin /
       //   index_sync_page)的 ack 成功**不清零** —— 否则每个 Segment 一次 begin 就把累计失败
       //   抹平,峰值恒 1、阈值 3 永不达,熔断形同虚设。
-      if (TERMINAL_SUCCESS_TYPES_V1.has(entry.type)) {
+      if (TERMINAL_SUCCESS_TYPES_PRE_V1.has(entry.type)) {
         breaker.consecutiveFailures = 0
         consecutiveTimeouts = 0
         halfOpenPending = false
@@ -489,7 +489,7 @@ export function createPythonSidecarClientPre(opts = {}) {
    */
   function request(type, payload, rOpts = {}) {
     if (disposed) return Promise.resolve({ ok: false, code: 'disposed' })
-    if (!RESPONSE_TYPE_FOR_V1[type]) return Promise.resolve({ ok: false, code: 'unsupported-frame' })
+    if (!RESPONSE_TYPE_FOR_PRE_V1[type]) return Promise.resolve({ ok: false, code: 'unsupported-frame' })
     if (breakerOpen()) {
       stats.failed.circuitOpen++
       return Promise.resolve({ ok: false, code: 'circuit-open', retryInMs: breaker.openUntil - Date.now() })
@@ -514,12 +514,12 @@ export function createPythonSidecarClientPre(opts = {}) {
     }
     const maxPending = Number(opt('maxPendingRequests', B.maxPendingRequests))
     if (pending.size >= maxPending) { stats.failed.backpressure++; return Promise.resolve({ ok: false, code: 'backpressure' }) }
-    const requestId = 'req_' + randomBytes(9).toString('hex') + (++reqCounter).toString(36)
+    const requestId = 'req_pre_' + randomBytes(9).toString('hex') + (++reqCounter).toString(36)
     const sentAt = Date.now()
     const mf = makeRequestFramePre({ type, payload, requestId, workerEpoch: epoch, sentAt })
     if (!mf.ok) { stats.failed.protocol++; return Promise.resolve({ ok: false, code: 'protocol', reason: mf.reason }) }
     return new Promise((resolve) => {
-      const entry = { requestId, type, expectedType: RESPONSE_TYPE_FOR_V1[type], resolve, settled: false, timer: null, signal: rOpts.signal || null, onAbort: null }
+      const entry = { requestId, type, expectedType: RESPONSE_TYPE_FOR_PRE_V1[type], resolve, settled: false, timer: null, signal: rOpts.signal || null, onAbort: null }
       pending.set(requestId, entry)
       stats.requests++
       const written = writeFrame(mf.frame)
@@ -549,9 +549,9 @@ export function createPythonSidecarClientPre(opts = {}) {
 
   /** fire-and-forget 帧(cancel/close_session;契约上无响应帧)。 */
   function notify(type, payload) {
-    if (disposed || !PY_FRAME_TYPES_V1) return
+    if (disposed || !PY_FRAME_TYPES_PRE_V1) return
     if (!child) return
-    const requestId = 'ntf_' + randomBytes(6).toString('hex')
+    const requestId = 'ntf_pre_' + randomBytes(6).toString('hex')
     const sentAt = Date.now()
     const mf = makeRequestFramePre({ type, payload, requestId, workerEpoch: epoch, sentAt })
     if (mf.ok) { if (writeFrame(mf.frame)) stats.cancelNotifications++ }
@@ -615,7 +615,7 @@ export function createPythonSidecarClientPre(opts = {}) {
   }
 
   return {
-    kind: 'python-sidecar-pre',
+    kind: 'python-sidecar',
     request, notify, health, restart, dispose, debugView,
     ensureStarted, isStarted, currentEpoch, processForTest, breakerOpenForTest: breakerOpen,
     // 测试钩子:确定性 framing 注入(partial/multiple/bad JSON/oversize/伪造帧)与最后出站帧检查

package/lib/recall-fusion.js

@@ -1,5 +1,5 @@
 /**
- * recall-fusion-pre —— rank-space 融合(P3, 2026-09-09; rrf_fusion_v1)。
+ * recall-fusion-pre —— rank-space 融合(P3, 2026-09-09; rrf_fusion_pre_v1)。
  *
  * 背景:旧 fuseD6Pre(semantic-js.js)为 minmax 加权融合,存在三宗罪:
  *   ① 分数随候选集漂移(归一化域=当前候选集) ② 矮子里拔将军(零极差臂全员 0.5)
@@ -16,15 +16,15 @@
  */
 
 /** RRF 常数 k(Hindsight issue #3956 实测: k=60 时动态范围安全,加权会退化排序)。 */
-export const FUSION_RRF_K_V1 = 60
+export const FUSION_RRF_K_PRE_V1 = 60
 
 /** rank 尺度常数:rank/divisor 把秩归到 (0,1] 量级(默认与 k 同值)。 */
-export const FUSION_RRF_DIVISOR_V1 = 60
+export const FUSION_RRF_DIVISOR_PRE_V1 = 60
 
 /**
  * ★M2.5b：层次优先级序（与注入侧一致）。
  *
- * 出处：`tier-layer-inject.js:58 TIER_LAYER_ORDER_V1` —— **必须与之逐字相同**。
+ * 出处：`tier-layer-inject.js:58 TIER_LAYER_ORDER_PRE_V1` —— **必须与之逐字相同**。
  *
  * 为什么不直接 import：本模块头注释承诺「**零依赖**、纯函数、零 IO」，
  *   引入跨模块依赖会破坏该契约（且 tier-layer-inject 自身还有依赖链）。
@@ -32,10 +32,10 @@ export const FUSION_RRF_DIVISOR_V1 = 60
  *   （见 smoke-test-m25b-layer-arm-pre.mjs 的「常量一致性」断言）——
  *   任何一侧改动而另一侧未同步，测试立刻红。
  */
-export const FUSION_LAYER_ORDER_V1 = Object.freeze(['project', 'whiteboard', 'user', 'reflection', 'log'])
+export const FUSION_LAYER_ORDER_PRE_V1 = Object.freeze(['project', 'whiteboard', 'user', 'reflection', 'log'])
 
 /** 版本标识。 */
-export const RECALL_FUSION_VERSION = 'rrf_fusion_v1'
+export const RECALL_FUSION_VERSION = 'rrf_fusion_pre_v1'
 
 /**
  * rank-space RRF 融合。
@@ -53,8 +53,8 @@ export const RECALL_FUSION_VERSION = 'rrf_fusion_v1'
  *   - 缺失臂贡献 0(不是 minmax 的 0.5)
  */
 export function rankFusionRRFPre(pairs, opts = {}) {
-  const k = Number.isFinite(opts.k) && opts.k >= 0 ? opts.k : FUSION_RRF_K_V1
-  const divisor = Number.isFinite(opts.divisor) && opts.divisor > 0 ? opts.divisor : FUSION_RRF_DIVISOR_V1
+  const k = Number.isFinite(opts.k) && opts.k >= 0 ? opts.k : FUSION_RRF_K_PRE_V1
+  const divisor = Number.isFinite(opts.divisor) && opts.divisor > 0 ? opts.divisor : FUSION_RRF_DIVISOR_PRE_V1
   const list = Array.isArray(pairs) ? pairs.filter((p) => p && typeof p.memoryId === 'string') : []
 
   // 每臂独立排名:非空有限值按分数降序(平局 memoryId 升序)取秩(1 起);缺席者无秩。
@@ -79,15 +79,15 @@ export function rankFusionRRFPre(pairs, opts = {}) {
 
   /**
    * ★M2.5b：层次臂的**序** = 注入侧的层次优先级序（二者必须一致）。
-   * 出处：`tier-layer-inject.js:58 TIER_LAYER_ORDER_V1`
+   * 出处：`tier-layer-inject.js:58 TIER_LAYER_ORDER_PRE_V1`
    *       = ['project','whiteboard','user','reflection','log']。
    * 语义：**rank 1 = 最高优先级层**。未列出的层（含新增层）排在已知层之后，按名称升序（确定性）。
    * 注意：这里只定义**偏好顺序**，不定义权重；权重问题走 rank-space（见下），
    *       需要调权重时应改分档/序，而不是给分数乘系数（Hindsight #3956）。
    */
   const layerRankOf = (name) => {
-    const i = FUSION_LAYER_ORDER_V1.indexOf(name)
-    return i >= 0 ? i : FUSION_LAYER_ORDER_V1.length
+    const i = FUSION_LAYER_ORDER_PRE_V1.indexOf(name)
+    return i >= 0 ? i : FUSION_LAYER_ORDER_PRE_V1.length
   }
   const cmpLayer = (a, b) => {
     const la = layerRankOf(String(a.v))
@@ -106,7 +106,7 @@ export function rankFusionRRFPre(pairs, opts = {}) {
   //   所有 pair 均缺 layer **或 layer 全相等** → 不构建 layer 秩，行为与三臂版**逐字节一致**
   //   （fused 不加 0 项、输出对象不含新字段）。
   // 为什么需要它（实测不一致，2026-09-18）：Tier-0 **注入**侧有层次优先级
-  //   （tier-layer-inject.js:58 TIER_LAYER_ORDER_V1 = ['project','whiteboard','user','reflection','log']
+  //   （tier-layer-inject.js:58 TIER_LAYER_ORDER_PRE_V1 = ['project','whiteboard','user','reflection','log']
   //    + tier0-catalog.js:419-455 的 caps/floors），而 **排序**侧对层次完全无感
   //   ⇒ 结论层（project）与流水层（log）在融合里**平等竞争**，笔记层常被日志挤掉。
   // rank-space（Hindsight #3956 禁止 score-space 加权）：层次只贡献**秩**，不乘分。

package/lib/recall-stats.js

@@ -22,7 +22,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, rmSync } from 'node:fs'
 import path from 'node:path'
 
-export const RECALL_STATS_VERSION_PRE = 'recall_stats_v1'
+export const RECALL_STATS_VERSION_PRE = 'recall_stats_pre_v1'
 
 /** 三条通路的稳定 id（写盘/前端都按它索引，禁止改拼写）。 */
 export const RECALL_CHANNELS_PRE = ['model', 'inject', 'shadow']
@@ -32,6 +32,17 @@ const MAX_ENTRIES = 2000
 /** 保留天数（按天分布只留最近 N 天）。 */
 const MAX_DAYS = 90
 
+/**
+ * ★A-11b（2026-09-23 用户拍板「按推荐方案全修」）：落盘**节流**间隔（毫秒）。
+ *
+ * 事故（有硬证据）：`observe()` / `observeInjection()` 此前只置 `dirty = true`，
+ * **全仓没有任何地方调 `.save()`**（只有 `reset()` 会）⇒ `~/.dsh/memory/recall-stats.json`
+ * 文件根本不存在 ⇒ 宿主一重启统计全清零（面板上看到的一直是"当前进程内"的数）。
+ * 修法：observe 尾部走 `maybeSave()` 节流落盘 —— 复用既有 `save()`，不新增开关。
+ * 间隔 2s：注入通路每轮调一次，节流后写盘成本可忽略，且重启最多丢最后 2s 的增量。
+ */
+const SAVE_THROTTLE_MS = 2000
+
 /**
  * @param {{file: () => string, now?: () => number}} opts
  *   `file()` 每次调用都重新解析路径（DSH_HOME 可能变），必须是函数而非字符串。
@@ -41,6 +52,8 @@ export function createRecallStatsPre(opts = {}) {
   const fileOf = typeof opts.file === 'function' ? opts.file : () => ''
   let state = null
   let dirty = false
+  // ★A-11b（2026-09-23）：上次落盘时刻，用于 observe 侧节流（见 maybeSave）。
+  let lastSaveAt = 0
 
   const dayOf = (ms) => {
     const d = new Date(ms)
@@ -118,6 +131,27 @@ export function createRecallStatsPre(opts = {}) {
     }
   }
 
+  /**
+   * ★A-11b（2026-09-23）：**节流落盘** —— observe 尾部唯一的写盘通路。
+   *
+   * 为什么必须有：本模块此前只 `dirty = true`，`save()` 除 `reset()` 外**无任何调用方**
+   * ⇒ 统计从不落盘、重启即清零（面板上"召回统计不更新"的真因之一）。
+   * 为什么节流：inject 通路**每轮**都会调 `observeInjection`，不节流就是每轮一次原子写。
+   * 节流窗口内只置 dirty，下次 observe 或显式 `save()`（含 reset）时补写 —— 不丢数据，
+   * 只把「多次增量」合并成「一次写」。`nowFn` 可注入 ⇒ 测试里能确定性地推进时钟。
+   *
+   * fail-soft：写失败不抛出（save() 内部已 try/catch，返回 false）。
+   * @returns {boolean} 本次是否真的写了盘
+   */
+  function maybeSave() {
+    if (!dirty) return false
+    const t = nowFn()
+    if (lastSaveAt && t - lastSaveAt < SAVE_THROTTLE_MS) return false
+    const ok = save()
+    if (ok) lastSaveAt = t
+    return ok
+  }
+
   /** 裁剪：**每通道**条目数上限 + 天数上限。按 count 升序淘汰最冷门的。 */
   function prune() {
     for (const ch of RECALL_CHANNELS_PRE) {
@@ -177,6 +211,7 @@ export function createRecallStatsPre(opts = {}) {
       }
       prune()
       dirty = true
+      maybeSave()
       return true
     } catch (_) { return false } // fail-soft：统计绝不影响召回
   }