@a9i5k4/dsh-auto-memory 3.1.5 → 3.1.6

package/lib/intent-clean-safe.js

@@ -5,7 +5,7 @@
  *
  * ★ 本次改动的根因（issue #30 / ③ Hermes 遗留 / H-3）：
  *   旧实现在 `:17` 用**一条字面量行首白名单** `/^(?:current runtime context\.|current dsh file policy:)/i`
- *   识别信封 ⇒ 只能挡住两个当期已知形态。真机取证（`~/.dsh/memory/hub/procedures.json`，
+ *   识别信封 ⇒ 只能挡住两个当期已知形态。真机取证（`~/.dsh/memory/hub-pre/procedures.json`，
  *   10 条 procedure 里 7 条 observed、其中 4 条 title 就是运行时信封）实测漏网 4 类：
  *     · `Approval prompts are disabled in this session: …`
  *     · `{"path":"D:\\…`（工具回包的 JSON 转储）
@@ -55,7 +55,7 @@ const HARNESS_HEAD_ZH_RE = /^(?:当前|批准|沙箱|策略|运行时|会话|权
  * **发现过程**：⑨ 探针逐条检验真机 `procedures.json` 的 11 条 title，
  * 发现**时间戳最新的一条**（2026-09-19）title 是 `[Retrieved memory refe` ——
  * 它正是**本插件自己注入的「记忆召回」块标记**
- * （`activation-inbox.js:58` 的 `TAIL_MARKER_LINE_V1`）。
+ * （`activation-inbox.js:58` 的 `TAIL_MARKER_LINE_PRE_V1`）。
  *
  * ⇒ **自污染闭环**：插件注入召回块 → 召回块随 userText 进 episode →
  *   `crossFeed()` 把它当成技能 title ⇒ 又回到「技能审批队列」。
@@ -246,7 +246,7 @@ export function stripRuntimeIntentPre(text) {
 }
 
 /** 导出判据本身，供套件直接断言（避免只能通过整串行为间接验证）。 */
-export const RUNTIME_ENVELOPE_V1 = Object.freeze({
+export const RUNTIME_ENVELOPE_PRE_V1 = Object.freeze({
   EXACT_ENVELOPE_RE,
   HARNESS_HEAD_RE,
   HARNESS_HEAD_ZH_RE,

package/lib/intent-clean.js

@@ -2,7 +2,7 @@
  * M8 采集侧 intent 清洗(2026-08-30 P1,docs/HANDOFF-M8-M9-M10.md §2 P1)。
  *
  * 背景:episode 的 intent 来自 consolidateTurn 取到的「本轮最后一条 user 文本」,而该文本
- * 在真实运行时常被三种形态污染(已实录于 ~/.dsh/memory/hub/episodes.json):
+ * 在真实运行时常被三种形态污染(已实录于 ~/.dsh/memory/hub-pre/episodes.json):
  *   ① harness 注入的上下文快照 —— 以 "Current runtime context. This snapshot supersedes…" 开头
  *   ② 工具回包 —— role 也是 user,但 eventType='tool/result',正文是 JSON 转储
  *   ③ 行号引用文本 —— 同属工具回包("436: ## 2026-08-25\n437: …")

package/lib/l0-extract.js

@@ -1,5 +1,5 @@
 /**
- * L0 抽取纯核心（l0_extract_v1）—— 分层语义唤回的地基。
+ * L0 抽取纯核心（l0_extract_pre_v1）—— 分层语义唤回的地基。
  *
  * 2026-09-08 建立。目的：为每条记忆生成廉价摘要（L0），使检索可先在小空间
  * 收敛候选，再按 id 下钻原文，从而把 token 开销与索引构建成本降约一个数量级
@@ -29,7 +29,7 @@
  * 空串/空数组），不抛异常。所有新增文本 UTF-8 无 BOM。
  */
 
-export const L0_EXTRACT_VERSION = 'l0_extract_v1'
+export const L0_EXTRACT_VERSION = 'l0_extract_pre_v1'
 
 /** 锚点：`<!-- memory:mem_<32hex> -->`（允许空白浮动）。 */
 const MEM_ANCHOR_RE = /<!--\s*memory:(mem_[0-9a-f]{32})\s*-->/g
@@ -103,7 +103,7 @@ export const L0_STATUSES = Object.freeze(['current', 'superseded', 'retracted'])
 export const L0_DEFAULT_LAYER = 'log'
 
 /** 层级契约版本（与 L0_EXTRACT_VERSION 分开：后者是抽取算法版本，已有断言锁定，不动）。 */
-export const L0_LAYER_VERSION = 'l0_layer_v1'
+export const L0_LAYER_VERSION = 'l0_layer_pre_v1'
 
 const clean = (s) => String(s == null ? '' : s).replace(/\u0000/g, '').trim()
 
@@ -157,15 +157,15 @@ export function classifyLayerPre(source) {
 
 /** R4-B（2026-09-18）：分层**呈现**用的层序（最高优先在前）。
  *
- * 与 `recall-fusion.js:FUSION_LAYER_ORDER_V1` / `tier-layer-inject.js:TIER_LAYER_ORDER_V1`
+ * 与 `recall-fusion.js:FUSION_LAYER_ORDER_PRE_V1` / `tier-layer-inject.js:TIER_LAYER_ORDER_PRE_V1`
  * **同序但独立声明** —— 本仓既有约定：跨模块不共享同一常量对象，避免一处改动静默改变另一处语义；
  * 三者相等由断言锁定（见 smoke-test-r4-recall-layers-pre.mjs）。 */
-export const L0_LAYER_DISPLAY_ORDER_V1 = Object.freeze(['project', 'whiteboard', 'user', 'reflection', 'log'])
+export const L0_LAYER_DISPLAY_ORDER_PRE_V1 = Object.freeze(['project', 'whiteboard', 'user', 'reflection', 'log'])
 
 /** R4-B：层 → 呈现标题。措辞刻意让「结论」与「流水」一眼可分 —— 这正是检索区分度问题的靶心：
  *  语义臂内部不分层（`index.js` 纯分数 sort）时，模型看到的 MEMORY.md（结论）与 2026-09-xx.md（流水）
  *  在视觉上完全同级，含金量被数量淹没。 */
-export const L0_LAYER_LABELS_V1 = Object.freeze({
+export const L0_LAYER_LABELS_PRE_V1 = Object.freeze({
   project: '结论层 · 项目笔记',
   user: '结论层 · 用户级记忆',
   whiteboard: '结论层 · 白板/账本',
@@ -174,7 +174,7 @@ export const L0_LAYER_LABELS_V1 = Object.freeze({
 })
 
 /** 判不出层时的兜底标题：**不猜层**，如实说"未分层"，且固定排在最后（避免给出错误的层次暗示）。 */
-export const L0_LAYER_UNKNOWN_LABEL_V1 = '未分层'
+export const L0_LAYER_UNKNOWN_LABEL_PRE_V1 = '未分层'
 
 /**
  * R4-B（2026-09-18）：把检索命中**按层分组**（**只改呈现，不改排序**）。
@@ -182,7 +182,7 @@ export const L0_LAYER_UNKNOWN_LABEL_V1 = '未分层'
  * 硬契约（与本仓"回滚必须逐字节相同"纪律对齐）：
  *   ① **不增删条目**：输出各组条目总数 = 入参长度，且**层内保持入参原相对顺序**
  *      ⇒ 调用方无需改排序；`#finalRank` 标签仍在行内，排序信息可完全还原；
- *   ② 组顺序 = `L0_LAYER_DISPLAY_ORDER_V1`；判不出层的固定归**末组**；
+ *   ② 组顺序 = `L0_LAYER_DISPLAY_ORDER_PRE_V1`；判不出层的固定归**末组**；
  *   ③ 空入参 / 非数组 / 取层函数抛错 → **永不抛**（fail-soft：呈现层失败绝不打断检索）。
  *
  * 调用方职责：**只有一组时不打标题** ⇒ 单一层（如纯日志命中）的输出与旧版逐字节相同。
@@ -210,14 +210,14 @@ export function groupL0ByLayerPre(items, layerOf) {
     //   `l && ...` 分支**当前不可达** —— 保留它是有意的前向兼容：将来 L0_LAYERS 扩容时，
     //   旧版调用方不会把新层误并入"未分层"，而是照实单独成组。
     //   （变异演示已证实：改这一段不会让任何断言变红 —— 它确实不参与当下语义。）
-    const ordered = L0_LAYER_DISPLAY_ORDER_V1.filter((l) => byLayer.has(l))
+    const ordered = L0_LAYER_DISPLAY_ORDER_PRE_V1.filter((l) => byLayer.has(l))
     for (const l of byLayer.keys()) if (l && ordered.indexOf(l) === -1) ordered.push(l)
     for (const l of ordered) {
-      groups.push({ layer: l, label: L0_LAYER_LABELS_V1[l] || l, items: byLayer.get(l) })
+      groups.push({ layer: l, label: L0_LAYER_LABELS_PRE_V1[l] || l, items: byLayer.get(l) })
     }
     // 未分层固定末组（不猜层）—— **不走通用流程**：它不属层词表，也不该排在结论层之前。
     if (byLayer.has('')) {
-      groups.push({ layer: '', label: L0_LAYER_UNKNOWN_LABEL_V1, items: byLayer.get('') })
+      groups.push({ layer: '', label: L0_LAYER_UNKNOWN_LABEL_PRE_V1, items: byLayer.get('') })
     }
   } catch (_) { /* fail-soft：分组失败即降级为"无分组"，调用方按单组处理，检索不受影响 */ }
   return groups
@@ -275,8 +275,8 @@ export function isRetrievablePre(record) {
 }
 
 /** 检索侧标记语的取值域（枚举类常量须配断言兜底 —— 本仓纪律）。 */
-export const L0_SUPERSEDED_MARK_V1 = '⚠已作废'
-export const L0_RETRACTED_MARK_V1 = '⚠已撤回'
+export const L0_SUPERSEDED_MARK_PRE_V1 = '⚠已作废'
+export const L0_RETRACTED_MARK_PRE_V1 = '⚠已撤回'
 
 /**
  * 为「返回但标记」生成**呈现后缀**（R4-A 的可见面）。
@@ -298,13 +298,13 @@ export function supersededMarkPre(record) {
     const idOf = (v) => (/^mem_[0-9a-f]{32}$/.test(String(v || '').trim()) ? String(v).trim() : '')
     if (record.status === 'superseded') {
       const safe = idOf(record.supersededBy)
-      return ' ' + L0_SUPERSEDED_MARK_V1 + (safe ? '（已被 ' + safe + ' 取代）' : '（已被更新结论取代）')
+      return ' ' + L0_SUPERSEDED_MARK_PRE_V1 + (safe ? '（已被 ' + safe + ' 取代）' : '（已被更新结论取代）')
     }
     if (record.status === 'retracted') {
       const safe = idOf(record.supersededBy)
       const reason = record.reason ? String(record.reason).replace(/[\r\n]+/g, ' ').trim().slice(0, 80) : ''
       const tail = (reason ? '原因：' + reason + '；' : '') + (safe ? '更正见 ' + safe : '已被撤回')
-      return ' ' + L0_RETRACTED_MARK_V1 + '（' + tail + '）'
+      return ' ' + L0_RETRACTED_MARK_PRE_V1 + '（' + tail + '）'
     }
     return ''
   } catch (_) { return '' }   // fail-soft：标记失败绝不影响检索

package/lib/l0-index-sync.js

@@ -1,5 +1,5 @@
 /**
- * L0 索引接线（l0_index_sync_v1）—— 三层检索契约 C3
+ * L0 索引接线（l0_index_sync_pre_v1）—— 三层检索契约 C3
  * （`docs/internal/THREE-LAYER-CONTRACT.md` §7 C3；接口规范 `SEMANTIC-ARCHITECTURE-SPEC.md` S1/S9）。
  *
  * 背景：`lib/l0-index.js`（L0 自己的向量索引，增量）长期**零引用**——文件在、能力在、
@@ -8,18 +8,18 @@
  *
  * ── 文件布局与命名（契约 C3）────────────────────────────────────────────
  *   <dir>/l0-index-<workspaceKey 短哈希>-<layer>.json
- *   例：~/.dsh/memory/semantic/l0/l0-index-9f2c1ab34de5-project.json
+ *   例：~/.dsh/memory/semantic-pre/l0/l0-index-9f2c1ab34de5-project.json
  *
  * 为什么**按层各一份文件**、而不是「一个工作区一份合并文件」（与任务书的字面表述有偏差，
  * 这是**能力边界**而非偷懒，见下）：
- *   `l0-index` 的 `buildFull`/`update` 每次调用只接受**单一 `layer`**
+ *   `l0-index-pre` 的 `buildFull`/`update` 每次调用只接受**单一 `layer`**
  *   （内部是 `buildL0IndexPre(text, { layer })` → 该次调用产出的**全部**条目同层）。
  *   工作区 L0 语料天然多层（project / user / log / reflection / whiteboard 五种来源同批），
  *   因此「一次调用产出一份含真实层归属的单文件」在该 API 下**无法表达**：
  *     - 传合并文本 + 任选一个 layer → 其余层的条目**全部落成错的层**（契约 I4 直接违反，
  *       这正是契约 C3 行里点名的「`:147/172` 未传层 → 会全落默认 log」同类错误）；
  *     - 沿用模块原样不动（任务书要求）时，唯一能保住层归属的实现就是**按层分文件**。
- *   若日后要「一份合并文件」，需要二选一：①给 `l0-index` 增一个多来源入口（改模块）；
+ *   若日后要「一份合并文件」，需要二选一：①给 `l0-index-pre` 增一个多来源入口（改模块）；
  *   ②在接线侧自己合并条目（等于把 `assemble()` 复制一份 → 同一文件格式两个写者，风险更高）。
  *   两条都未做，交由契约方裁定（见交付报告「未完成/存疑」）。
  *
@@ -37,7 +37,7 @@ import { createHash } from 'node:crypto'
 import { L0_LAYERS } from './l0-extract.js'
 import { createL0IndexPre } from './l0-index.js'
 
-export const L0_INDEX_SYNC_VERSION = 'l0_index_sync_v1'
+export const L0_INDEX_SYNC_VERSION = 'l0_index_sync_pre_v1'
 
 /** 索引文件名前缀（契约 C3 命名：`l0-index-<workspaceKey 短哈希>`）。 */
 export const L0_INDEX_FILE_PREFIX = 'l0-index-'
@@ -63,7 +63,7 @@ export function l0IndexFileNamePre(workspaceKey, layer, chars = L0_INDEX_WS_HASH
  * 工厂：L0 索引同步器（IO / 嵌入 / 读文本 全注入）。
  *
  * @param {object} opts
- * @param {{readJson(path):any, writeJson(path,obj):void}} opts.io 落盘 IO（同 l0-index 契约；
+ * @param {{readJson(path):any, writeJson(path,obj):void}} opts.io 落盘 IO（同 l0-index-pre 契约；
  *        readJson 对缺失文件返回 null 或抛 ENOENT 均可被模块层容错）。
  * @param {{embedPassages(texts:string[]):Promise<Float32Array[]|number[][]>}} opts.embedder
  *        端侧嵌入通道（宿主机注入 `_jsSemantic.embedPassages`；测试注入假 embedder）。
@@ -80,7 +80,7 @@ export function createL0IndexSyncPre(opts = {}) {
   const engineIdentity = typeof opts.engineIdentity === 'string' ? opts.engineIdentity : ''
   const engineIdentityGate = opts.engineIdentityGate
   const crossIdReuse = opts.crossIdReuse
-  // 工厂级配置错误直接抛（调用方组装错，不属运行期 fail-soft 范畴）——与 l0-index 同口径。
+  // 工厂级配置错误直接抛（调用方组装错，不属运行期 fail-soft 范畴）——与 l0-index-pre 同口径。
   if (!io || typeof io.readJson !== 'function' || typeof io.writeJson !== 'function') {
     throw new Error('l0-index-sync-pre: io.readJson/io.writeJson required')
   }
@@ -101,7 +101,7 @@ export function createL0IndexSyncPre(opts = {}) {
    * @param {object} o
    * @param {boolean} o.enabled 总开关 —— 非 true 直接返回 disabled，**零 IO**（宿主 `l0IndexEnabled`，默认 true）。
    * @param {string} o.workspaceKey 工作区键（进文件名短哈希）。
-   * @param {string} o.dir 索引目录（<dshHome>/memory/semantic/l0）。
+   * @param {string} o.dir 索引目录（<dshHome>/memory/semantic-pre/l0）。
    * @param {Array<{layer:string, path:string, text?:string}>} o.sources 来源（text 已给则不读盘）。
    * @param {number} [o.maxChars] / @param {number} [o.minChars] 透传 l0-extract-pre 的抽取参数。
    * @param {()=>number} [o.now] 时间注入（测试确定性）。

package/lib/l0-index.js

@@ -1,5 +1,5 @@
 /**
- * L0 向量索引（l0_index_v1）—— 为 T1 产出的 L0 建立向量索引,供语义检索使用。
+ * L0 向量索引（l0_index_pre_v1）—— 为 T1 产出的 L0 建立向量索引,供语义检索使用。
  *
  * 2026-09-09 建立(P1)。参照 OpenViking「Vector Index 只存 URI+向量+元数据,不含文件内容」:
  * 每条目仅 {id, vector, l0, source, l0Hash, updatedAt},**绝不存记忆原文**。
@@ -13,8 +13,8 @@
  *
  * 身份与版本约定(沿用仓库惯例):
  *   - l0Hash = sha256(l0),增量重算的唯一判据(l0 不变 → 跳过该条)
- *   - l0IndexVersion = 'l0idx_' + first32hex(sha256(canonical sorted [id,l0Hash] tuples))
- *     (前缀 l0idx_ 有意区别于 corpus 的 idx_ memoryIndexVersion,避免两套版本语义混淆)
+ *   - l0IndexVersion = 'l0idx_pre_' + first32hex(sha256(canonical sorted [id,l0Hash] tuples))
+ *     (前缀 l0idx_pre_ 有意区别于 corpus 的 idx_pre_ memoryIndexVersion,避免两套版本语义混淆)
  *   - 向量维度由 embedder 决定(真实 C2 引擎为 384 维已归一化),本模块不硬编码维度
  *   - 向量以纯 number 数组存盘(JSON 安全);embedder 返回 Float32Array 时经 Array.from 转换
  *
@@ -25,7 +25,7 @@ import { createHash } from 'node:crypto'
 import { buildL0IndexPre, L0_LAYERS, L0_STATUSES, L0_DEFAULT_LAYER } from './l0-extract.js'
 import { isEngineIdentityPre } from './engine-identity.js'
 
-export const L0_INDEX_VERSION = 'l0_index_v1'
+export const L0_INDEX_VERSION = 'l0_index_pre_v1'
 export const L0_INDEX_SCHEMA_VERSION = 1
 
 /**
@@ -55,7 +55,7 @@ function normalizeVector(vec) {
 }
 
 /**
- * l0IndexVersion:canonical sorted [id,l0Hash,**layer,status**] tuples → 'l0idx_' + first32hex(sha256)。
+ * l0IndexVersion:canonical sorted [id,l0Hash,**layer,status**] tuples → 'l0idx_pre_' + first32hex(sha256)。
  * 同内容同版本(确定性);任一条目 l0 变化、层归属或状态变化、条目增删 → 版本变化。
  * (C3：层/状态进身份,否则「同一条记忆换层」不会触发版本变化 → 下游缓存会拿到过期归属。)
  */
@@ -68,7 +68,7 @@ export function computeL0IndexVersionPre(entries) {
       normStatusPre(e && e.status),
     ])
     .sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
-  return 'l0idx_' + sha256Hex(JSON.stringify(canon)).slice(0, 32)
+  return 'l0idx_pre_' + sha256Hex(JSON.stringify(canon)).slice(0, 32)
 }
 
 /**
@@ -92,7 +92,7 @@ export function createL0IndexPre(opts = {}) {
   const crossIdReuse = opts.crossIdReuse !== false
   if (!io || typeof io.readJson !== 'function' || typeof io.writeJson !== 'function') {
     // fail closed:工厂级配置错误直接抛(调用方组装错误,不属于运行期 fail-soft 范畴)
-    throw new Error('l0-index: io.readJson/io.writeJson required')
+    throw new Error('l0-index-pre: io.readJson/io.writeJson required')
   }
 
   /** fail-soft 读取+整文件校验。任何异常/不符 → {ok:false, reason, entries:[]}。 */
@@ -101,7 +101,7 @@ export function createL0IndexPre(opts = {}) {
       const obj = io.readJson(path)
       if (!obj || typeof obj !== 'object') return { ok: false, reason: 'missing', entries: [] }
       if (obj.schemaVersion !== L0_INDEX_SCHEMA_VERSION) return { ok: false, reason: 'schema', entries: [] }
-      if (typeof obj.l0IndexVersion !== 'string' || !obj.l0IndexVersion.startsWith('l0idx_')) {
+      if (typeof obj.l0IndexVersion !== 'string' || !obj.l0IndexVersion.startsWith('l0idx_pre_')) {
         return { ok: false, reason: 'version', entries: [] }
       }
       // ★P2 T2-9 引擎身份门：文件声明的引擎身份与当前引擎不一致 ⇒ 整文件判不可用，
@@ -180,11 +180,11 @@ export function createL0IndexPre(opts = {}) {
     if (needEmbed.length) {
       const vecs = await embedder.embedPassages(needEmbed.map((x) => x.text))
       if (!Array.isArray(vecs) || vecs.length !== needEmbed.length) {
-        throw new Error('l0-index: embedder returned ' + (Array.isArray(vecs) ? vecs.length : 'non-array') + ' vectors for ' + needEmbed.length + ' passages')
+        throw new Error('l0-index-pre: embedder returned ' + (Array.isArray(vecs) ? vecs.length : 'non-array') + ' vectors for ' + needEmbed.length + ' passages')
       }
       needEmbed.forEach((x, i) => {
         const v = normalizeVector(vecs[i])
-        if (!v) throw new Error('l0-index: embedder produced invalid vector at index ' + i)
+        if (!v) throw new Error('l0-index-pre: embedder produced invalid vector at index ' + i)
         vecsByEmbeddedHash.set(x.hash, v)
       })
     }
@@ -199,7 +199,7 @@ export function createL0IndexPre(opts = {}) {
         else reusedByHash++
       } else {
         vector = vecsByEmbeddedHash.get(hash)
-        if (!vector) throw new Error('l0-index: missing vector for ' + it.id)
+        if (!vector) throw new Error('l0-index-pre: missing vector for ' + it.id)
       }
       const prev = prevById ? prevById.get(it.id) : null
       // updatedAt 语义：整条（同 id 同 hash）复用时保留原时间；跨 id 复用属"新条目指向旧向量"，按新条记时。

package/lib/ledger-criteria.js

@@ -20,15 +20,15 @@ export { checkHandoffCriteriaPre as checkHandoffCriteriaContractPre, checkPlanCr
 import { parseHandoffLedgerPre } from './handoff-anchor.js'
 
 /** 交接账本四段权威标题(与 handoff-anchor.js 权重表同源)。 */
-export const HANDOFF_SECTIONS_V1 = Object.freeze(['任务状态', '目标', '已试方案与失败原因', '进度与下一步'])
+export const HANDOFF_SECTIONS_PRE_V1 = Object.freeze(['任务状态', '目标', '已试方案与失败原因', '进度与下一步'])
 
 /** 占位符黑名单(借 dsh-graph CRITERIA_PLACEHOLDERS 技巧, 方案 H3)。 */
-export const CRITERIA_PLACEHOLDERS_V1 = Object.freeze(['(待补充)', '（待补充）', 'TODO', '同上', '略', 'N/A', 'n/a'])
+export const CRITERIA_PLACEHOLDERS_PRE_V1 = Object.freeze(['(待补充)', '（待补充）', 'TODO', '同上', '略', 'N/A', 'n/a'])
 
 /** 账本硬上限(H4, 与 sanitizeForWrite 8000 同源, 先于它执行)。 */
-export const LEDGER_MAX_CHARS_V1 = 8000
+export const LEDGER_MAX_CHARS_PRE_V1 = 8000
 /** 白板硬上限(P-H2, 200000)。 */
-export const PLAN_MAX_CHARS_V1 = 200000
+export const PLAN_MAX_CHARS_PRE_V1 = 200000
 
 function nz(s) { return String(s || '') }
 
@@ -40,7 +40,7 @@ function sectionBodies(parsed) {
 function isPlaceholderLine(line) {
   const t = nz(line).trim()
   if (!t) return false
-  return CRITERIA_PLACEHOLDERS_V1.some((p) => t === p || t === '-' + p || t === '*' + p)
+  return CRITERIA_PLACEHOLDERS_PRE_V1.some((p) => t === p || t === '-' + p || t === '*' + p)
 }
 
 /** H2: 每段 body 非空(≥1 非空行且合计 ≥20 字符)。 */
@@ -64,7 +64,7 @@ export function checkHandoffCriteriaPre(text) {
 
   // H1 四段标题齐全且逐字匹配
   const titles = parsed ? sectionBodies(parsed).map((x) => x.title) : []
-  const missing = HANDOFF_SECTIONS_V1.filter((t) => !titles.includes(t))
+  const missing = HANDOFF_SECTIONS_PRE_V1.filter((t) => !titles.includes(t))
   hard.push({ id: 'H1', pass: !!parsed && missing.length === 0, missing: parsed ? missing.map((t) => '缺段:' + t) : ['解析失败(无任何 ## 段)'] })
 
   // H2 每段非空
@@ -78,7 +78,7 @@ export function checkHandoffCriteriaPre(text) {
 
   // H4 总长 ≤8000
   const len = nz(text).length
-  hard.push({ id: 'H4', pass: len <= LEDGER_MAX_CHARS_V1, missing: len > LEDGER_MAX_CHARS_V1 ? ['总长 ' + len + ' > ' + LEDGER_MAX_CHARS_V1] : [] })
+  hard.push({ id: 'H4', pass: len <= LEDGER_MAX_CHARS_PRE_V1, missing: len > LEDGER_MAX_CHARS_PRE_V1 ? ['总长 ' + len + ' > ' + LEDGER_MAX_CHARS_PRE_V1] : [] })
 
   // S1 每段 ≤5 行(软)
   const overLong = parsed ? sectionBodies(parsed).filter((x) => x.body.filter((l) => l.trim()).length > 5).map((x) => x.title) : []
@@ -119,7 +119,7 @@ export function checkPlanCriteriaPre(text) {
   const nonEmptySections = sections.filter((s) => s.body.join('').replace(/\s/g, '').length >= 20)
   hard.push({ id: 'P-H1', pass: nonEmptySections.length >= 1, missing: nonEmptySections.length === 0 ? ['无非空 ## 顶层节(全部节被老化走或空白板)'] : [] })
   // P-H2 长度
-  hard.push({ id: 'P-H2', pass: src.length <= PLAN_MAX_CHARS_V1, missing: src.length > PLAN_MAX_CHARS_V1 ? ['总长 ' + src.length + ' > ' + PLAN_MAX_CHARS_V1] : [] })
+  hard.push({ id: 'P-H2', pass: src.length <= PLAN_MAX_CHARS_PRE_V1, missing: src.length > PLAN_MAX_CHARS_PRE_V1 ? ['总长 ' + src.length + ' > ' + PLAN_MAX_CHARS_PRE_V1] : [] })
   // P-S1 前瞻内容(软)
   const s1pass = /下一步|待办|计划|todo/i.test(src)
   soft.push({ id: 'P-S1', pass: s1pass, detail: s1pass ? '' : '建议含前瞻内容(下一步/待办/计划)' })

package/lib/m4-corpus.js

@@ -17,7 +17,7 @@ import { readFileSync, existsSync, statSync, realpathSync } from 'node:fs'
 import path from 'node:path'
 import { createHash } from 'node:crypto'
 import { parseSidecar } from './memory-anchor.js'
-import { memoryIndexVersion as computeIndexVersion, SHADOW_LEXICAL_BUDGET_V1 as BUDGET } from './shadow-retrieval.js'
+import { memoryIndexVersion as computeIndexVersion, SHADOW_LEXICAL_BUDGET_PRE_V1 as BUDGET } from './shadow-retrieval.js'
 
 const sha256Hex = (buf) => createHash('sha256').update(buf).digest('hex')
 const INDEX_MAX_FILE_BYTES = 5 * 1024 * 1024

package/lib/m7-index-sync-host.js

@@ -26,7 +26,7 @@ import { buildIndexSyncPlansPre, sendIndexSyncPlanPre } from './index-sync.js'
 import { workspaceRefOf } from './evidence-store.js'
 import { createEngineSwitchPre } from './engine-switch.js'
 
-export const M7_INDEX_SYNC_HOST_POLICY_VERSION = 'm7_index_sync_host_v1'
+export const M7_INDEX_SYNC_HOST_POLICY_VERSION = 'm7_index_sync_host_pre_v1'
 const MAX_DROPS = 16
 
 export function createIndexSyncHostPre(opts = {}) {
@@ -86,7 +86,7 @@ export function createIndexSyncHostPre(opts = {}) {
     if (!snapshot || !snapshot.records || !snapshot.records.length) return { ok: false, ready: false, reason: 'empty-corpus' }
     const wsRef = workspaceRefOf(paths.workspaceKey)
     const miv = String(snapshot.memoryIndexVersion || '')
-    if (!miv.startsWith('idx_')) return { ok: false, ready: false, reason: 'bad-miv' }
+    if (!miv.startsWith('idx_pre_')) return { ok: false, ready: false, reason: 'bad-miv' }
     const epoch = currentEpoch()
     const k = keyOf(wsRef, scope)
     const cached = readyCache.get(k)

package/lib/m7-wire.js

@@ -3,7 +3,7 @@
  * 零 IO、零依赖(node:crypto);本模块不 spawn、不监听、不读文件、不改 M5/M6 schema。
  *
  * 组成:
- *   1) 协议常量(m7_wire_v1 / 传输预算 / 帧类型两个不相交集合 / 请求→响应对应)
+ *   1) 协议常量(m7_wire_pre_v1 / 传输预算 / 帧类型两个不相交集合 / 请求→响应对应)
  *   2) canonical JSON + SHA-256(JS 与 Python worker 的逐字节一致实现;排序键、无空白、UTF-8)
  *   3) M7TransportFramePre envelope validator(fail closed;方向门)
  *   4) SemanticRecordPre / IndexSyncBegin/Page/Commit payload validators(M7-1)
@@ -16,11 +16,11 @@ const sha256Hex = (buf) => createHash('sha256').update(buf).digest('hex')
 const sha256Str = (s) => sha256Hex(Buffer.from(String(s), 'utf8'))
 const first32 = (h) => h.slice(0, 32)
 
-export const M7_WIRE_PROTOCOL_VERSION_V1 = 'm7_wire_v1'
-export const M7_INDEX_POLICY_VERSION_V1 = 'index_sync_v1'
+export const M7_WIRE_PROTOCOL_VERSION_PRE_V1 = 'm7_wire_pre_v1'
+export const M7_INDEX_POLICY_VERSION_PRE_V1 = 'index_sync_pre_v1'
 
 /** §7 传输预算(冻结;变更必须升级协议版本)。 */
-export const M7_TRANSPORT_BUDGET_V1 = Object.freeze({
+export const M7_TRANSPORT_BUDGET_PRE_V1 = Object.freeze({
   schemaVersion: 1,
   maxLineBytes: 256 * 1024,
   requestTimeoutMs: 5000,
@@ -31,17 +31,17 @@ export const M7_TRANSPORT_BUDGET_V1 = Object.freeze({
 })
 
 /** JS→Python frame 类型(§7.2;index_sync_* 属 M7-1;recall_rank 属 P13 recall C3 语义臂)。 */
-export const JS_FRAME_TYPES_V1 = Object.freeze([
+export const JS_FRAME_TYPES_PRE_V1 = Object.freeze([
   'health', 'context_push', 'index_sync_begin', 'index_sync_page', 'index_sync_commit',
   'cancel', 'close_session', 'recall_rank',
 ])
 /** Python→JS frame 类型。 */
-export const PY_FRAME_TYPES_V1 = Object.freeze([
+export const PY_FRAME_TYPES_PRE_V1 = Object.freeze([
   'health_result', 'context_ack', 'index_ack', 'activation_request', 'error', 'recall_rank_result',
 ])
-const ALL_FRAME_TYPES = new Set([...JS_FRAME_TYPES_V1, ...PY_FRAME_TYPES_V1])
+const ALL_FRAME_TYPES = new Set([...JS_FRAME_TYPES_PRE_V1, ...PY_FRAME_TYPES_PRE_V1])
 /** 请求→响应 type 对应(cancel/close_session 刻意无响应帧)。 */
-export const RESPONSE_TYPE_FOR_V1 = Object.freeze({
+export const RESPONSE_TYPE_FOR_PRE_V1 = Object.freeze({
   health: 'health_result',
   context_push: 'context_ack',
   index_sync_begin: 'index_ack',
@@ -50,7 +50,7 @@ export const RESPONSE_TYPE_FOR_V1 = Object.freeze({
   recall_rank: 'recall_rank_result',
 })
 
-// ========== canonical JSON(与 python/worker_v1.py 逐字节一致) ==========
+// ========== canonical JSON(与 python/worker_pre_v1.py 逐字节一致) ==========
 
 /**
  * 确定性 canonical JSON:对象键递归排序、无空白、非 ASCII 原样 UTF-8、undefined 剔除。
@@ -82,15 +82,15 @@ export function sha256Canonical(value) {
 export function validateTransportFramePre(frame, opts = {}) {
   const p = []
   if (!frame || typeof frame !== 'object' || Array.isArray(frame)) return { ok: false, reason: 'not-object' }
-  if (frame.protocolVersion !== M7_WIRE_PROTOCOL_VERSION_V1) p.push('protocolVersion')
+  if (frame.protocolVersion !== M7_WIRE_PROTOCOL_VERSION_PRE_V1) p.push('protocolVersion')
   if (typeof frame.frameId !== 'string' || !frame.frameId) p.push('frameId')
   if (typeof frame.requestId !== 'string') p.push('requestId')
   if (typeof frame.workerEpoch !== 'string' || !frame.workerEpoch) p.push('workerEpoch')
   if (!ALL_FRAME_TYPES.has(frame.type)) p.push('type')
   if (!frame.payload || typeof frame.payload !== 'object' || Array.isArray(frame.payload)) p.push('payload')
   if (typeof frame.sentAt !== 'number' || !Number.isFinite(frame.sentAt)) p.push('sentAt')
-  if (!p.length && opts.direction === 'in' && !PY_FRAME_TYPES_V1.includes(frame.type)) p.push('direction')
-  if (!p.length && opts.direction === 'out' && !JS_FRAME_TYPES_V1.includes(frame.type)) p.push('direction')
+  if (!p.length && opts.direction === 'in' && !PY_FRAME_TYPES_PRE_V1.includes(frame.type)) p.push('direction')
+  if (!p.length && opts.direction === 'out' && !JS_FRAME_TYPES_PRE_V1.includes(frame.type)) p.push('direction')
   if (p.length) return { ok: false, reason: 'invalid:' + p.join(',') }
   return { ok: true, frame }
 }
@@ -103,8 +103,8 @@ export function makeRequestFramePre(input) {
   const requestId = String((input && input.requestId) || '')
   const sentAt = Number(input && input.sentAt)
   const frame = {
-    protocolVersion: M7_WIRE_PROTOCOL_VERSION_V1,
-    frameId: 'frm_' + first32(sha256Str(JSON.stringify(['m7-frame-v1', type, requestId, sentAt]))),
+    protocolVersion: M7_WIRE_PROTOCOL_VERSION_PRE_V1,
+    frameId: 'frm_pre_' + first32(sha256Str(JSON.stringify(['m7-frame-pre-v1', type, requestId, sentAt]))),
     requestId,
     workerEpoch: String((input && input.workerEpoch) || ''),
     type,
@@ -119,7 +119,7 @@ export function makeRequestFramePre(input) {
 
 const MEMORY_ID_RE = /^mem_[0-9a-f]{32}$/
 const HEX64_RE = /^[0-9a-f]{64}$/
-const IDX_VERSION_RE = /^idx_[0-9a-f]{32}$/
+const IDX_VERSION_RE = /^idx_pre_[0-9a-f]{32}$/
 const WORKSPACE_REF_RE = /^wsr_[0-9a-f]{32}$/
 /** 与 M5/M6 同一相对引用白名单(user:/workspace:/workspace-log:+文件名)。 */
 const SOURCE_REF_RE = new RegExp('^(user|workspace|workspace-log):[A-Za-z0-9._\\u4e00-\\u9fff-]+$')
@@ -142,7 +142,7 @@ export function validateSemanticRecordPre(rec) {
   if (rec.heading !== undefined && rec.heading !== null && typeof rec.heading !== 'string') p.push('heading')
   if (typeof rec.text !== 'string') p.push('text')
   if (rec.occurredAt !== undefined && rec.occurredAt !== null && !Number.isFinite(rec.occurredAt)) p.push('occurredAt')
-  if (typeof rec.chunkId !== 'string' || !rec.chunkId.startsWith('chk_')) p.push('chunkId')
+  if (typeof rec.chunkId !== 'string' || !rec.chunkId.startsWith('chk_pre_')) p.push('chunkId')
   if (!Number.isInteger(rec.chunkOrdinal) || rec.chunkOrdinal < 0) p.push('chunkOrdinal')
   if (!Number.isInteger(rec.chunkCount) || rec.chunkCount < 1 || rec.chunkOrdinal >= rec.chunkCount) p.push('chunkCount')
   if (p.length) return { ok: false, reason: 'invalid:' + p.join(',') }
@@ -154,7 +154,7 @@ export function validateIndexSyncBeginPre(pl) {
   const p = []
   if (!pl || typeof pl !== 'object') return { ok: false, reason: 'not-object' }
   if (pl.schemaVersion !== 1) p.push('schemaVersion')
-  if (typeof pl.syncId !== 'string' || !pl.syncId.startsWith('syn_')) p.push('syncId')
+  if (typeof pl.syncId !== 'string' || !pl.syncId.startsWith('syn_pre_')) p.push('syncId')
   if (typeof pl.workspaceRef !== 'string' || !WORKSPACE_REF_RE.test(pl.workspaceRef)) p.push('workspaceRef')
   if (pl.scope !== 'Workspace' && pl.scope !== 'User') p.push('scope')
   if (typeof pl.memoryIndexVersion !== 'string' || !IDX_VERSION_RE.test(pl.memoryIndexVersion)) p.push('memoryIndexVersion')
@@ -170,7 +170,7 @@ export function validateIndexSyncBeginPre(pl) {
   }
   if (!Number.isInteger(pl.recordCount) || pl.recordCount < 0) p.push('recordCount')
   if (!Number.isInteger(pl.pageCount) || pl.pageCount < 0) p.push('pageCount')
-  if (pl.indexPolicyVersion !== M7_INDEX_POLICY_VERSION_V1) p.push('indexPolicyVersion')
+  if (pl.indexPolicyVersion !== M7_INDEX_POLICY_VERSION_PRE_V1) p.push('indexPolicyVersion')
   if (!p.length && (pl.recordCount === 0) !== (pl.pageCount === 0)) p.push('count-consistency')
   if (p.length) return { ok: false, reason: 'invalid:' + p.join(',') }
   return { ok: true, payload: pl }
@@ -181,7 +181,7 @@ export function validateIndexSyncPagePre(pl) {
   const p = []
   if (!pl || typeof pl !== 'object') return { ok: false, reason: 'not-object' }
   if (pl.schemaVersion !== 1) p.push('schemaVersion')
-  if (typeof pl.syncId !== 'string' || !pl.syncId.startsWith('syn_')) p.push('syncId')
+  if (typeof pl.syncId !== 'string' || !pl.syncId.startsWith('syn_pre_')) p.push('syncId')
   if (!Number.isInteger(pl.pageNo) || pl.pageNo < 0) p.push('pageNo')
   if (!Number.isInteger(pl.pageCount) || pl.pageCount < 0) p.push('pageCount')
   if (typeof pl.pageDigest !== 'string' || !HEX64_RE.test(pl.pageDigest)) p.push('pageDigest')
@@ -196,7 +196,7 @@ export function validateIndexSyncCommitPre(pl) {
   const p = []
   if (!pl || typeof pl !== 'object') return { ok: false, reason: 'not-object' }
   if (pl.schemaVersion !== 1) p.push('schemaVersion')
-  if (typeof pl.syncId !== 'string' || !pl.syncId.startsWith('syn_')) p.push('syncId')
+  if (typeof pl.syncId !== 'string' || !pl.syncId.startsWith('syn_pre_')) p.push('syncId')
   if (typeof pl.memoryIndexVersion !== 'string' || !IDX_VERSION_RE.test(pl.memoryIndexVersion)) p.push('memoryIndexVersion')
   if (typeof pl.finalDigest !== 'string' || !HEX64_RE.test(pl.finalDigest)) p.push('finalDigest')
   if (p.length) return { ok: false, reason: 'invalid:' + p.join(',') }
@@ -208,7 +208,7 @@ export function validateIndexAckPayloadPre(pl) {
   const p = []
   if (!pl || typeof pl !== 'object') return { ok: false, reason: 'not-object' }
   if (pl.schemaVersion !== 1) p.push('schemaVersion')
-  if (typeof pl.syncId !== 'string' || !pl.syncId.startsWith('syn_')) p.push('syncId')
+  if (typeof pl.syncId !== 'string' || !pl.syncId.startsWith('syn_pre_')) p.push('syncId')
   if (!['begin', 'page', 'commit'].includes(pl.phase)) p.push('phase')
   if (typeof pl.accepted !== 'boolean') p.push('accepted')
   if (pl.accepted === false && (typeof pl.reason !== 'string' || !pl.reason)) p.push('reason')
@@ -224,12 +224,12 @@ export function validateIndexAckPayloadPre(pl) {
 
 /** 派生 chunk 身份(占位 chunking=整记录单 chunk;M7-2 tokenizer 落地前冻结此派生规则)。 */
 export function buildChunkIdPre(memoryId, recordDigest) {
-  return 'chk_' + first32(sha256Str(JSON.stringify(['semantic-chunk-v1', String(memoryId || ''), String(recordDigest || '')])))
+  return 'chk_pre_' + first32(sha256Str(JSON.stringify(['semantic-chunk-pre-v1', String(memoryId || ''), String(recordDigest || '')])))
 }
 
 /** syncId:由 workspaceRef+scope+memoryIndexVersion+recordCount 确定(同快照重放同 id)。 */
 export function buildSyncIdPre(workspaceRef, scope, memoryIndexVersion, recordCount) {
-  return 'syn_' + first32(sha256Str(JSON.stringify(['index-sync-v1', String(workspaceRef || ''), String(scope || ''), String(memoryIndexVersion || ''), Number(recordCount) | 0])))
+  return 'syn_pre_' + first32(sha256Str(JSON.stringify(['index-sync-pre-v1', String(workspaceRef || ''), String(scope || ''), String(memoryIndexVersion || ''), Number(recordCount) | 0])))
 }
 
 /** pageDigest = sha256(canonical(records 数组))。 */
@@ -243,7 +243,7 @@ export function computePageDigestPre(records) {
  */
 export function computeFinalDigestPre(input) {
   return sha256Canonical({
-    kind: 'index_sync_final_v1',
+    kind: 'index_sync_final_pre_v1',
     syncId: String(input.syncId || ''),
     memoryIndexVersion: String(input.memoryIndexVersion || ''),
     workspaceRef: String(input.workspaceRef || ''),

package/lib/memory-anchor.js

@@ -22,7 +22,7 @@ import { createHash, randomUUID } from 'node:crypto'
 import { splitByteLines, INDEX_MAX_FILE_BYTES } from './memory-index.js'
 
 export const SIDECAR_SCHEMA_VERSION = 1
-export const SIDECAR_NAMESPACE = 'dsh-auto-memory'
+export const SIDECAR_NAMESPACE = 'dsh-auto-memory-pre'
 export const ANCHOR_PREFIX = 'memory:'
 export const MEMORY_ID_RE = /^mem_[0-9a-f]{32}$/
 export const MARKER_RE = /^<!-- memory:(mem_[0-9a-f]{32}) -->$/