@a9i5k4/dsh-auto-memory 3.1.4 → 3.1.6

package/lib/memory-envelope.js

@@ -1,5 +1,5 @@
 /**
- * 记忆注入信封 · 分项账本（memory_envelope_v1）—— 契约 T0-3 / 总纲 §0.5 第 6 条。
+ * 记忆注入信封 · 分项账本（memory_envelope_pre_v1）—— 契约 T0-3 / 总纲 §0.5 第 6 条。
  *
  * 2026-09-14 建立（P0）。**为什么需要这个模块**：
  *
@@ -15,7 +15,7 @@
  * **分项账本**：`chars: { rules, memoryReferences, otherDynamic, total }` +
  * `limits: { memoryReferences, otherDynamic }`。
  *
- * **本模块的三条不变式**（每条都有能红的断言，见 `tests/smoke/smoke-test-t0-3-budget-ledger-pre.mjs`）：
+ * **本模块的三条不变式**（每条都有能红的断言，见 `tests/smoke/smoke-test-t0-3-budget-ledger.mjs`）：
  *   E1 **总计 = 最终序列化长度**：`chars.total === text.length`（逐字节相等，不是估算）。
  *   E2 **不允许未计费尾巴**：每个字符都归属某个分项；`rules + memoryReferences + otherDynamic === total`。
  *      标题、分隔符、降级说明**都必须作为某一段的文本被计入**（本模块不给任何"隐含前缀"留位置）。
@@ -34,10 +34,10 @@
  * UTF-8 无 BOM。
  */
 
-export const MEMORY_ENVELOPE_VERSION = 'memory_envelope_v1'
+export const MEMORY_ENVELOPE_VERSION = 'memory_envelope_pre_v1'
 
 /** 分项取值域（固定顺序仅用于**账本展示**；序列化顺序仍由调用方决定）。 */
-export const ENVELOPE_BUCKETS_V1 = Object.freeze(['rules', 'memoryReferences', 'otherDynamic'])
+export const ENVELOPE_BUCKETS_PRE_V1 = Object.freeze(['rules', 'memoryReferences', 'otherDynamic'])
 
 /**
  * 段落优先级（★2026-09-15 新增）—— 决定"超额时先丢谁"。
@@ -50,19 +50,19 @@ export const ENVELOPE_BUCKETS_V1 = Object.freeze(['rules', 'memoryReferences', '
  * - `normal`：默认档。
  * - `low`：先丢（如最近日志——量最大、时效性最强、可从文件重读）。
  */
-export const ENVELOPE_PRIORITIES_V1 = Object.freeze(['low', 'normal', 'must'])
+export const ENVELOPE_PRIORITIES_PRE_V1 = Object.freeze(['low', 'normal', 'must'])
 const PRIORITY_RANK = Object.freeze({ low: 0, normal: 1, must: 2 })
 const normalizePriority = (v) => (Object.prototype.hasOwnProperty.call(PRIORITY_RANK, String(v)) ? String(v) : 'normal')
 
 /** 分项中文名（面板/日志可读；I7 精神：机器枚举之外要有人话）。 */
-export const ENVELOPE_BUCKET_TEXT_V1 = Object.freeze({
+export const ENVELOPE_BUCKET_TEXT_PRE_V1 = Object.freeze({
   rules: '规则类',
   memoryReferences: '记忆参考类',
   otherDynamic: '其他动态内容',
 })
 
 /** 账本相关的原因码 → 可读中文。 */
-export const ENVELOPE_REASONS_V1 = Object.freeze({
+export const ENVELOPE_REASONS_PRE_V1 = Object.freeze({
   'over-limit-dropped': '整段丢弃（超出分项上限）',
   'over-limit-truncated': '截断（单段本身即超上限）',
   'over-budget-total': '合计超出注入预算（分项账本如实记录，不掩盖）',
@@ -100,7 +100,7 @@ export function composeMemoryEnvelopePre(input = {}) {
   const segs = rawSegs.map((s, i) => {
     const text = clean(s && s.text)
     let bucket = clean(s && s.bucket)
-    if (!ENVELOPE_BUCKETS_V1.includes(bucket)) {
+    if (!ENVELOPE_BUCKETS_PRE_V1.includes(bucket)) {
       degradations.push({
         code: 'unknown-bucket', bucket: 'otherDynamic',
         text: '[降级] 第 ' + (i + 1) + ' 段分项名非法（' + (bucket || '(空)') + '）→ 已计入其他动态内容，未丢弃',
@@ -159,7 +159,7 @@ export function composeMemoryEnvelopePre(input = {}) {
         // 全是 must ⇒ 不丢，如实报告超额（I7：可见，但不牺牲最高价值内容）
         degradations.push({
           code: 'over-limit-must', bucket, inject: true,
-          text: '[降级] ' + ENVELOPE_BUCKET_TEXT_V1[bucket] + '超出分项上限 ' + lim + ' 字符，但剩余 '
+          text: '[降级] ' + ENVELOPE_BUCKET_TEXT_PRE_V1[bucket] + '超出分项上限 ' + lim + ' 字符，但剩余 '
             + mine.length + ' 段均为 must 级（不可丢）⇒ 本轮**保留全部**并如实报告超额 '
             + (bucketTotal(bucket) - lim) + ' 字符（不静默丢弃硬性内容）',
         })
@@ -173,7 +173,7 @@ export function composeMemoryEnvelopePre(input = {}) {
         dropped.push({ bucket, kind: victim.kind, chars: victim.text.length, priority: victim.priority, reason: 'over-limit-dropped' })
         degradations.push({
           code: 'over-limit-dropped', bucket, inject: true,
-          text: '[降级] ' + ENVELOPE_BUCKET_TEXT_V1[bucket] + '超出分项上限 ' + lim + ' 字符 → 丢弃优先级最低的一段'
+          text: '[降级] ' + ENVELOPE_BUCKET_TEXT_PRE_V1[bucket] + '超出分项上限 ' + lim + ' 字符 → 丢弃优先级最低的一段'
             + (victim.kind ? '（' + victim.kind + '，priority=' + normalizePriority(victim.priority) + '）' : '')
             + '，未静默',
         })
@@ -187,7 +187,7 @@ export function composeMemoryEnvelopePre(input = {}) {
         dropped.push({ bucket, kind: only.kind, chars: only.text.length, priority: only.priority, reason: 'over-limit-truncated' })
         degradations.push({
           code: 'over-limit-truncated', bucket, inject: true,
-          text: '[降级] ' + ENVELOPE_BUCKET_TEXT_V1[bucket] + '上限 ' + lim + ' 字符过小（放不下截断标记）→ 本段本轮为空',
+          text: '[降级] ' + ENVELOPE_BUCKET_TEXT_PRE_V1[bucket] + '上限 ' + lim + ' 字符过小（放不下截断标记）→ 本段本轮为空',
         })
       } else {
         const before = only.text.length
@@ -201,14 +201,14 @@ export function composeMemoryEnvelopePre(input = {}) {
         truncated.push({ bucket, kind: only.kind, charsBefore: before, charsAfter: only.text.length, reason: 'over-limit-truncated' })
         degradations.push({
           code: 'over-limit-truncated', bucket, inject: true,
-          text: '[降级] ' + ENVELOPE_BUCKET_TEXT_V1[bucket] + '只剩一段仍超上限 ' + lim + ' 字符 → 已截断（' + before + ' → ' + only.text.length + '）',
+          text: '[降级] ' + ENVELOPE_BUCKET_TEXT_PRE_V1[bucket] + '只剩一段仍超上限 ' + lim + ' 字符 → 已截断（' + before + ' → ' + only.text.length + '）',
         })
       }
       // 截断后复核：must 段自身超限时如实报告，不假装达标
       if (bucketTotal(bucket) > lim) {
         degradations.push({
           code: 'over-limit-must', bucket, inject: true,
-          text: '[降级] ' + ENVELOPE_BUCKET_TEXT_V1[bucket] + '截断后仍超上限 ' + lim + ' 字符（剩余为 must 级不可丢）⇒ 如实报告超额 '
+          text: '[降级] ' + ENVELOPE_BUCKET_TEXT_PRE_V1[bucket] + '截断后仍超上限 ' + lim + ' 字符（剩余为 must 级不可丢）⇒ 如实报告超额 '
             + (bucketTotal(bucket) - lim) + ' 字符',
         })
       }
@@ -227,7 +227,7 @@ export function composeMemoryEnvelopePre(input = {}) {
   // ── ④ 超额可见性：分项账本如实记录，**不用任何写法掩盖**（v2 明确要求） ──
   const budgetChars = Number.isFinite(Number(o.budgetChars)) && Number(o.budgetChars) > 0 ? Math.floor(Number(o.budgetChars)) : null
   if (budgetChars !== null && chars.total > budgetChars) {
-    const parts = ENVELOPE_BUCKETS_V1.map((b) => ENVELOPE_BUCKET_TEXT_V1[b] + ' ' + chars[b]).join(' · ')
+    const parts = ENVELOPE_BUCKETS_PRE_V1.map((b) => ENVELOPE_BUCKET_TEXT_PRE_V1[b] + ' ' + chars[b]).join(' · ')
     degradations.push({
       code: 'over-budget-total', bucket: null, inject: false,
       text: '[降级] 合计 ' + chars.total + ' 字符超出注入预算 ' + budgetChars + '（分项账本如实记录: ' + parts
@@ -252,6 +252,6 @@ export function composeMemoryEnvelopePre(input = {}) {
 /** 分项账本 → 单行可读文本（进降级行 / 面板 / 排障都用它，口径唯一）。 */
 export function describeEnvelopeCharsPre(envelope) {
   const c = (envelope && envelope.chars) || { rules: 0, memoryReferences: 0, otherDynamic: 0, total: 0 }
-  return ENVELOPE_BUCKETS_V1.map((b) => ENVELOPE_BUCKET_TEXT_V1[b] + ' ' + (c[b] || 0)).join(' · ')
+  return ENVELOPE_BUCKETS_PRE_V1.map((b) => ENVELOPE_BUCKET_TEXT_PRE_V1[b] + ' ' + (c[b] || 0)).join(' · ')
     + ' · 合计 ' + (c.total || 0)
 }

package/lib/memory-hub.js

@@ -26,10 +26,52 @@ import { isObservationOnlyPre } from './procedure-observation.js'
  */
 import { createHash } from 'node:crypto'
 
-export const MEMORY_HUB_POLICY_VERSION = 'memory_hub_v1'
+export const MEMORY_HUB_POLICY_VERSION = 'memory_hub_pre_v1'
+
+/**
+ * ★A-10b（2026-09-23 用户拍板「按推荐方案全修」）：条目「观察数」= evidence 各计数之和。
+ *
+ * 用途：待审批列表的**主排序键**（用户指定口径：观察数降序 → 同数按时间新→旧）。
+ * 只读；缺字段按 0 —— 旧快照或异常来源可能缺键（同名规范化在 procedure-store 的
+ * `normalizeEvidencePre` 里，本模块不重复实现，只做无副作用的读数兜底）。
+ *
+ * @param {object} p 条目
+ * @returns {number}
+ */
+function evidenceTotalPre(p) {
+  const ev = (p && p.evidence) || {}
+  const n = (v) => Number(v) || 0
+  return n(ev.seen) + n(ev.read) + n(ev.cite) + n(ev.reuse) + n(ev.success) + n(ev.correction)
+}
+
+/** 比较器：观察数降序 → 时间新→旧（时间取自 updatedAt，缺则 createdAt，再缺按 0）。 */
+function pipelineCmpPre(a, b) {
+  const d = evidenceTotalPre(b) - evidenceTotalPre(a)
+  if (d) return d
+  const ts = (p) => Number((p && (p.updatedAt || p.createdAt)) || 0)
+  return ts(b) - ts(a)
+}
+
+/**
+ * ★A-10b（2026-09-23）：待审批列表排序 —— **只在投影层排，不动 store.query() 本体**。
+ *
+ * 为什么不在 `procedure-store.js` 的 `query()` 里加 `.sort()`：`query()` 有多个消费方
+ * （hub 投影 / 测试 / 其它只读面），改它等于改所有消费方的顺序契约；而排序是**这一张列表的展示口径**。
+ *
+ * 用户指定口径（原话「观察数降序 → 同数按时间新→旧」）：见 `pipelineCmpPre`。
+ * `Array.prototype.sort` 在本机 V8 上是稳定排序 ⇒ 同键保持 store 内原有相对顺序。
+ *
+ * ★调用点写法定死：必须**链在 `.filter(...).map(...)` 的尾巴上**（即 `pipeline:` 那个投影表达式的最后一段），
+ *   **不得**把比较器包在 `stores.procedures.query()` 调用外面。原因：`smoke-test-r2-promotion.mjs`
+ *   的 R2a-2 用**字面量锚点**（`pipeline:` 紧跟 `stores.procedures.query()`）作为源码切片起点来锁「只读路径」，
+ *   包在外面会让切片起点落在别处、断言取不到 evaluatePromotion ⇒ 打红那条守卫（**实测踩过**：
+ *   连本注释里逐字写出该锚点都会把 `indexOf` 引到注释上，故本注释刻意拆开写）。
+ *   R2a-2 守的**语义**是「pipeline 必须从只读 query() 出发、且不得调 promote()」，
+ *   链尾加排序不改变该语义 ⇒ 按守卫守的语义调整写法，不改守卫。
+ */
 
 /** judgement-shadow 8 类候选 → 记忆层映射(不识别的不消费)。 */
-export const KIND_TO_LAYER_V1 = Object.freeze({
+export const KIND_TO_LAYER_PRE_V1 = Object.freeze({
   semantic_candidate: 'semantic',
   profile_candidate: 'semantic',
   procedure_candidate: 'procedure',
@@ -53,7 +95,11 @@ export function createMemoryHubPre(opts = {}) {
   const { createProcedureStorePre } = opts._stores || {}
   // ★T10：机械 procedure 切片开关（默认关闭；缺省值在 index.js 的 DEFAULT_CONFIG）。
   //   这里只读、不判定语义 —— 具体用途见 crossFeed() 的 procedure 分支。
-  const mechanicalProcedureFeedEnabled = opts.mechanicalProcedureFeedEnabled === true
+  // ★A-1（2026-09-23）：机械 procedure 切片开关**已退役**（用户裁定「机械通路已被我弃用」）。
+  //   原 `mechanicalProcedureFeedEnabled` 只包住 crossFeed 里那条 `intent.slice(0,40)` 分支；
+  //   该分支产出的观察行既非真技能、又要用户在审批列表里手动清理 ⇒ 整段删除。
+  //   ⚠️ 只删该分支：fact 分支、episode 巩固、judgement 消费一律不受影响（用户硬规矩
+  //   「单一开关不得顺带改变其他功能行为」）。index.js 对应 getter 与设置项同轮一并移除。
   const nowFn = typeof opts.now === 'function' ? opts.now : () => Date.now()
   const log = typeof opts.log === 'function' ? opts.log : () => {}
 
@@ -76,7 +122,7 @@ export function createMemoryHubPre(opts = {}) {
   function ingestJudgement(row) {
     if (!row || typeof row !== 'object') { stats.skipped++; return { skipped: true, reason: 'not-object' } }
     const kind = row.kindCandidate
-    const layer = KIND_TO_LAYER_V1[kind]
+    const layer = KIND_TO_LAYER_PRE_V1[kind]
     if (!layer) { stats.skipped++; return { skipped: true, reason: 'unknown-kind:' + kind } }
     stats.judgedRows++
     try {
@@ -195,47 +241,27 @@ export function createMemoryHubPre(opts = {}) {
       // 把 actions 直接当成 steps 会让观察行看起来像真流程,且与后续同名富候选撞车后被合并
       // 而丢失富候选的 successCriteria(晋升永久卡死)。现在显式标 observationOnly=true,
       // 并在 title 前过滤运行时信封(避免注入文本变成技能标题)。
-      const procedureIntent = stripRuntimeIntentPre(ep.intent).trim()
-      // ★T10（2026-09-20 用户报「技能名/内容看不懂」）：**门控机械切片**。
-      //   关闭时整段跳过 ⇒ 不再产出 `intent.slice(0,40)` 这种机械观察行。
-      //   ⚠️ 只包住 procedure 分支：下方 fact 分支与循环外的逻辑一律不受影响。
-      if (mechanicalProcedureFeedEnabled && ep.success && stores.procedures && procedureIntent && procedureIntent !== '(未提取)' && ep.actions && ep.actions.length) {
-        const cand = {
-          title: procedureIntent.slice(0, 40),
-          riskLevel: 'low',
-          steps: ['观察任务：' + procedureIntent.slice(0, 80)],
-          observationOnly: true,
-          sourceEpisodes: [ep.episodeId],
-          sourceMemoryIds: [],
-        }
-        const r = stores.procedures.observe(cand)
-        out.push({ from: 'episode', to: 'procedure', outcome: r.ok ? 'observed' : r.reason })
-      }
-      // 有未决事项的 episode → 事实候选(不直接固化,留给 judgement)
-      if (ep.unresolved && ep.unresolved.length && stores.facts) {
-        // ★ T1-1（2026-09-19 真机追加）：**fact 分支必须与 procedure 分支同样过清洗器**。
-        //   根因：上面 procedure 分支早已调 `stripRuntimeIntentPre`（:152），但本分支直接用
-        //   **未清洗**的 `ep.intent` ⇒ 运行时信封/U+FFFD 原样进 facts.json ⇒ 前端面板乱码（⑩-a），
-        //   且经 `hubFlushTick` 写回 `MEMORY.md` 污染注入面与语义语料（⑩-b）。实测证据：
-        //   `fact_ac4920327df6601f25200d66e52df71f` 的 subject 含 22 个 U+FFFD；
-        //   另两条的 object 内嵌 `Current DSH file policy: …` / `Approval prompts are disabled …`。
-        //   清洗后再截断，且**空值回退**到 'episode'（保持原 `|| 'episode'` 语义不变）。
-        //   ★ F5（行内残留）：清洗器是**按行**判断的，真人与信封挤在同一行时整行必须保留
-        //   （删了会丢人话）⇒ 此时「清洗后是否变化」检测不到脏。故再补一道 `looksRuntimeResiduePre`：
-        //   该字段**含任何运行时痕迹即整体判脏并丢弃**（置空 ⇒ 走下面的空值回退），
-        //   而不是把半截信封写进 facts.json。
-        const rawIntent = String(ep.intent == null ? '' : ep.intent)
-        const rawObject = String(ep.unresolved[0] == null ? '' : ep.unresolved[0])
-        const factIntent = looksRuntimeResiduePre(rawIntent) ? '' : stripRuntimeIntentPre(rawIntent).trim()
-        const factObject = looksRuntimeResiduePre(rawObject) ? '' : stripRuntimeIntentPre(rawObject).trim()
-        const cand = {
-          scope: 'Workspace', subject: factIntent.slice(0, 30) || 'episode', predicate: '有未决事项',
-          object: factObject.slice(0, 60), sourceKind: 'inference',
-          sourceClass: 'semantic-candidate', provenance: [ep.episodeId],
-        }
-        const r = stores.facts.upsert(cand)
-        out.push({ from: 'episode', to: 'fact', outcome: r.outcome })
-      }
+      // ★A-1（2026-09-23，用户裁定「机械通路已被我弃用」）：**机械 procedure 切片整段删除**。
+      //   这里原本是 `intent.slice(0,40)` 造观察行 —— 无模型介入、产出的既不是技能名也不是
+      //   步骤，只会堆在审批列表里等用户手动清理。开关 `hubMechanicalProcedureFeedEnabled`
+      //   及其设置项、getter 同轮一并移除（该开关只服务这一条分支）。
+      //   ⚠️ 只删这一段：下方 fact 分支、episode 巩固、judgement 消费一律不受影响
+      //   （用户硬规矩「单一开关不得顺带改变其他功能的行为」）。
+      //   ⇒ procedural 线的写入自此只剩两条正经通路：模型直写 memory_procedure、用户手动。
+      // ★M8-R2（2026-09-23，用户拍板）：**删除「情节 → 事实」这条设计外的边**。
+      //   背景：设计图的三个 store 输入是分开画的 —— 事实吃判定影子的语义/画像候选，
+      //   情节只喂技能。本处曾多出一条图上没有的边，判据仅要求待决数组非空，
+      //   而待决抽取是「凡含问号即命中」的纯正则 ⇒ **用户随口一问即被当成事实来源**。
+      //
+      //   实测后果（报告 docs/internal/M8-PATHWAY-REVIEW-20260923.md §3）：
+      //   该边累计产出 11 条事实，**11/11 全部是用户口语残句**（谓词统一为「有未决事项」），
+      //   零条可用知识；其中一条经回写通路进入项目长期记忆并被每轮无条件注入，
+      //   导致下一轮把一段过期的用户原话当成实时指令执行。
+      //
+      //   ⇒ 判据：**情节记录的是「发生过什么」，不是「世界是什么样」**。
+      //     会话状态（未决事项）属过程数据，不得升格为长期记忆。
+      //     本边删除后，事实层的输入只剩设计规定的两条（判定影子 + 解析富化）。
+      //   ⚠️ 只删这一条边：下方 episode 巩固、judgement 消费、技能观察一律不受影响。
     }
     return { ok: true, fed: out }
   }
@@ -269,7 +295,12 @@ export function createMemoryHubPre(opts = {}) {
       } : null,
       procedures: stores.procedures ? {
         size: stores.procedures.size,
-        active: stores.procedures.activeProcedures().map((p) => ({ procedureId: p.procedureId, title: p.title, stage: p.stage, riskLevel: p.riskLevel, evidence: p.evidence })),
+        // ★M8-B 第6步（2026-09-23）：投影**必须带上归属库**。前端双库视图要回答
+        //   「这条技能属于哪个库」，而缺省语义是 `global`（字段缺失=通用库，见
+        //   procedure-store.js 的 PROCEDURE_DEFAULT_SCOPE_PRE_V1）⇒ 这里显式补齐缺省，
+        //   让前端拿到的是**已解释过**的值，而不是「undefined 该当通用库还是未知」。
+        //   纯增字段：既有消费方按名取用，不受影响（同 A-10b 补 updatedAt/createdAt 的手法）。
+        active: stores.procedures.activeProcedures().map((p) => ({ procedureId: p.procedureId, title: p.title, stage: p.stage, riskLevel: p.riskLevel, evidence: p.evidence, scope: p.scope === 'workspace' ? 'workspace' : 'global', workspaceRef: p.workspaceRef || '', addedBy: p.addedBy || '' })),
         candidates: stores.procedures.query({ stage: 'candidate' }).map((p) => ({ procedureId: p.procedureId, title: p.title, stage: p.stage })),
         // 2026-08-30 审批面:全部未 active/未 deprecated 技能(observed/candidate/validated),
         // 供 hubTab 审批按钮(晋升/激活/弃用)操作
@@ -302,12 +333,20 @@ export function createMemoryHubPre(opts = {}) {
             return {
               procedureId: p.procedureId, title: p.title, stage: p.stage, riskLevel: p.riskLevel,
               evidence: p.evidence, pinned: !!p.pinned, observationOnly: isObservationOnlyPre(p),
+              // ★M8-B 第6步（2026-09-23）：归属库 + 添加者，供前端「这条属于哪个库」与
+              //   转移操作（提升为全局 / 收纳到工作区）。缺省显式补齐为 global（同 active 投影）。
+              scope: p.scope === 'workspace' ? 'workspace' : 'global',
+              workspaceRef: p.workspaceRef || '', addedBy: p.addedBy || '',
+              // ★A-10b（2026-09-23）：排序的次键需要时间戳 —— 投影行**必须带上**，
+              //   否则 sortPipelinePre 的 `updatedAt || createdAt` 恒为 0，同观察数时退化成磁盘序。
+              //   纯增字段（既有消费方按名取用，不受影响）。
+              updatedAt: p.updatedAt, createdAt: p.createdAt,
               // R4 预览用：晋升后会注入的真实 checklist 文本
               steps: Array.isArray(p.steps) ? p.steps.slice(0, 12) : [],
               successCriteria: Array.isArray(p.successCriteria) ? p.successCriteria.slice(0, 6) : [],
               promotion,
             }
-          }),
+          }).sort(pipelineCmpPre),
         stats: stores.procedures.getStats ? stores.procedures.getStats() : null,
       } : null,
     }
@@ -315,7 +354,7 @@ export function createMemoryHubPre(opts = {}) {
 
   function snapshot() {
     return {
-      schemaVersion: 1, namespace: 'dsh-auto-memory', policyVersion: MEMORY_HUB_POLICY_VERSION,
+      schemaVersion: 1, namespace: 'dsh-auto-memory-pre', policyVersion: MEMORY_HUB_POLICY_VERSION,
       savedAt: nowFn(),
       episodic: stores.episodic ? stores.episodic.snapshot() : null,
       facts: stores.facts ? stores.facts.snapshot({ includeRevoked: true }) : null,
@@ -377,8 +416,14 @@ export function procedureCandidateFromRow(row) {
   if (kind !== 'procedure_candidate') return null
   const sourceIds = Array.isArray(row.sourceIds) ? row.sourceIds : []
   if (!sourceIds.length) return null
-  // 行内通常只有 memoryId 引用 + 摘要; 步骤用可用的文本特征
-  const title = String(row.title || ('流程 ' + sourceIds[0].slice(-8)))
+  // ★A-2（2026-09-23，用户报「技能库里全是『流程 d3c24f99』这种一句话」）：
+  //   **没有真标题就不生成候选** —— 旧实现用 `'流程 ' + sourceIds[0].slice(-8)` 兜底，
+  //   于是一条只有 memoryId 的行会被造成「流程 xxxxxxxx」的技能，库里 9 条此类占位。
+  //   兜底是"为了不丢行"，但对技能库而言**造一条垃圾比丢一条行更贵**：它会出现在
+  //   审批列表、可能被注入、还要用户手动清理。⇒ 改为拒收（返回 null，上层按 not-procedure 跳过）。
+  //   判据与 procedureCandidateFromRow 的其余校验同源：**宁缺毋滥**。
+  const title = String(row.title || '').trim()
+  if (!title) return null
   const excerpt = String(row.excerpt || row.predicate || '').slice(0, 200)
   return {
     title: title.slice(0, 60),

package/lib/memory-importance.js

@@ -1,5 +1,5 @@
 /**
- * memory-importance-pre —— evidence → importance 纯核心(M8-2, 2026-09-09; memory_importance_v1)。
+ * memory-importance-pre —— evidence → importance 纯核心(M8-2, 2026-09-09; memory_importance_pre_v1)。
  *
  * 背景(M8-2 任务书):六类证据 seen/read/cite/reuse/success/correction 已由 M5 写入
  * (lib/context-bridge.js:45 枚举),消费侧聚合为 fact-store.js:341 evidenceFor(memoryId)
@@ -23,13 +23,13 @@
  * 数据不可达;待 P3 RRF 实际接线时作为加权因子之一落点(importance 禁止作为唯一排序依据)。
  */
 
-export const MEMORY_IMPORTANCE_VERSION = 'memory_importance_v1'
+export const MEMORY_IMPORTANCE_VERSION = 'memory_importance_pre_v1'
 
 /** 中性值:无 evidence 记录时返回,保证不因此置顶或垫底。 */
-export const IMPORTANCE_NEUTRAL_V1 = 0.5
+export const IMPORTANCE_NEUTRAL_PRE_V1 = 0.5
 
 /** 权重常数(冻结;调整即新版本)。 */
-export const IMPORTANCE_WEIGHTS_V1 = Object.freeze({
+export const IMPORTANCE_WEIGHTS_PRE_V1 = Object.freeze({
   diversityDivisor: 3, // distinctSessions 饱和点:≥3 个不同会话记满
   successReuseDivisor: 4, // success+reuse 饱和点:合计 ≥4 次记满
   posGain: 0.3, // 正向增益上限(0.5 + 0.3 = 0.8)
@@ -57,14 +57,14 @@ export function computeImportancePre(agg) {
   const total = seen + read + cite + reuse + success + correction
   // 无任何证据 → 中性(0.5):既不置顶也不垫底(验收 3)
   if (total === 0 && distinctSessions === 0) {
-    return { importance: IMPORTANCE_NEUTRAL_V1, correctionRate: 0, neutral: true, total: 0 }
+    return { importance: IMPORTANCE_NEUTRAL_PRE_V1, correctionRate: 0, neutral: true, total: 0 }
   }
   // correctionRate 口径与 procedure-store.js:268-269 逐字一致(禁止另立)
   const correctionRate = total > 0 ? correction / total : 0
-  const w = IMPORTANCE_WEIGHTS_V1
+  const w = IMPORTANCE_WEIGHTS_PRE_V1
   const diversity = Math.min(1, distinctSessions / w.diversityDivisor)
   const successReuse = Math.min(1, (success + reuse) / w.successReuseDivisor)
   const pos = 0.5 * diversity + 0.5 * successReuse
-  const importance = clamp01(IMPORTANCE_NEUTRAL_V1 + w.posGain * pos - w.negGain * correctionRate)
+  const importance = clamp01(IMPORTANCE_NEUTRAL_PRE_V1 + w.posGain * pos - w.negGain * correctionRate)
   return { importance, correctionRate, neutral: false, total }
 }

package/lib/memory-mutation.js

@@ -1,5 +1,5 @@
 /**
- * 记忆写入保护门（memory_mutation_v1）—— 3.0 主体拥有「共同提交与保护入口」。
+ * 记忆写入保护门（memory_mutation_pre_v1）—— 3.0 主体拥有「共同提交与保护入口」。
  *
  * 2026-09-14 建立（P0）。**边界（总纲 §0.5 / ROUND3 §3.1 定案，必须遵守）**：
  *   - **本模块**只接收**规范化投影**：`{beforeIds, afterIds, protectedRegions, changes}`。
@@ -13,7 +13,7 @@
  *   实际事故是「白板被整篇覆盖成骨架」（规范已批准、代码从未实现）。
  *   2026-09-14 实测缺口：`PLAN.md` 一个锚点、一个分区标记都没有。
  *
- * **三条保护**（每条都有能红断言，见 `tests/smoke/smoke-test-t0-8-mutation-gate-pre.mjs`）：
+ * **三条保护**（每条都有能红断言，见 `tests/smoke/smoke-test-t0-8-mutation-gate.mjs`）：
  *   M1 **丢卡保护**：`beforeIds` 里有、`afterIds` 里没有的 id，必须出现在 `archived` 里（显式归档 + 留痕）；
  *      否则**拒绝写入**并报出差异清单（不是静默接受）。
  *   M2 **用户区保护**（B4 预授权默认值：每卡分「模型维护区 / 用户备注区」）：
@@ -31,10 +31,10 @@
  */
 import { createHash } from 'node:crypto'
 
-export const MEMORY_MUTATION_VERSION = 'memory_mutation_v1'
+export const MEMORY_MUTATION_VERSION = 'memory_mutation_pre_v1'
 
 /** 拒绝/提示的原因码 → 可读中文。 */
-export const MUTATION_REASONS_V1 = Object.freeze({
+export const MUTATION_REASONS_PRE_V1 = Object.freeze({
   'card-disappeared': '卡片消失且无归档记录（契约 §4：不允许凭空消失）',
   'protected-region-lost': '受保护区域（用户备注区）未被原样带回',
   'protected-region-modified': '受保护区域被改动（必须逐字节保留）',
@@ -46,7 +46,7 @@ export const MUTATION_REASONS_V1 = Object.freeze({
 /** 原因码 → 可读中文（未知码原样返回）。 */
 export function describeMutationReasonPre(code) {
   const k = String(code == null ? '' : code)
-  return MUTATION_REASONS_V1[k] || k || '未知原因'
+  return MUTATION_REASONS_PRE_V1[k] || k || '未知原因'
 }
 
 const asStringArray = (v) => (Array.isArray(v) ? v.map((x) => String(x == null ? '' : x)).filter(Boolean) : null)

package/lib/note-status-apply.js

@@ -18,7 +18,7 @@
  *
  * 纪律：纯函数、零 IO、fail-soft（不改动即返回 null，绝不返回半成品文本）。
  */
-import { NOTE_STATUS_OPEN_V1, renderStatusLinePre, stripStatusLinePre, statusOfBodyPre } from './note-status.js'
+import { NOTE_STATUS_OPEN_PRE_V1, renderStatusLinePre, stripStatusLinePre, statusOfBodyPre } from './note-status.js'
 
 /** 锚点：与 `l0-extract.js` / `memory-anchor.js` 同形态（此处独立声明，避免耦合）。 */
 const ANCHOR_RE = /<!--\s*memory:(mem_[0-9a-f]{32})\s*-->/g
@@ -115,4 +115,4 @@ export function readRecordStatusPre(text, memoryId) {
 }
 
 /** 供反向锁使用：确认本模块**不碰锚点语法**。 */
-export const NOTE_STATUS_MARKER_V1 = NOTE_STATUS_OPEN_V1
+export const NOTE_STATUS_MARKER_PRE_V1 = NOTE_STATUS_OPEN_PRE_V1

package/lib/note-status.js

@@ -29,7 +29,7 @@
  */
 
 /** 状态行开标记。**刻意不复用** `MARKER_OPEN`（`<!-- memory:`）—— 复用会撞锚点契约。 */
-export const NOTE_STATUS_OPEN_V1 = '<!-- dsh-status:'
+export const NOTE_STATUS_OPEN_PRE_V1 = '<!-- dsh-status:'
 
 /**
  * 状态行语法（F1 候选 (a)：HTML 注释形态）。
@@ -49,10 +49,10 @@ const NOTE_STATUS_ATTR_RE = /(\w+)=(?:"([^"]*)"|([^\s"]+))/g
 const MEMORY_ID_RE = /^mem_[0-9a-f]{32}$/
 
 /** 三态取值域（与 `l0-extract.js` 的 `L0_STATUSES` 同源；此处独立声明以免循环依赖）。 */
-export const NOTE_STATUSES_V1 = Object.freeze(['current', 'superseded', 'retracted'])
+export const NOTE_STATUSES_PRE_V1 = Object.freeze(['current', 'superseded', 'retracted'])
 
 /** reason 上限：状态行是**元数据**不是正文，超长即视为脏数据。 */
-export const NOTE_STATUS_REASON_MAX_V1 = 120
+export const NOTE_STATUS_REASON_MAX_PRE_V1 = 120
 
 /**
  * 渲染状态行（**纯函数**）。
@@ -67,11 +67,11 @@ export const NOTE_STATUS_REASON_MAX_V1 = 120
 export function renderStatusLinePre(status, opts = {}) {
   try {
     if (status !== 'superseded' && status !== 'retracted') return ''
-    let line = NOTE_STATUS_OPEN_V1 + ' ' + status
+    let line = NOTE_STATUS_OPEN_PRE_V1 + ' ' + status
     const by = opts && opts.supersededBy ? String(opts.supersededBy).trim() : ''
     if (MEMORY_ID_RE.test(by)) line += ' by=' + by
     const reason = opts && opts.reason
-      ? String(opts.reason).replace(/[\r\n]+/g, ' ').replace(/--+>/g, '').trim().slice(0, NOTE_STATUS_REASON_MAX_V1)
+      ? String(opts.reason).replace(/[\r\n]+/g, ' ').replace(/--+>/g, '').trim().slice(0, NOTE_STATUS_REASON_MAX_PRE_V1)
       : ''
     if (reason) line += ' reason="' + reason.replace(/"/g, "'") + '"'
     return line + ' -->'
@@ -101,7 +101,7 @@ export function parseStatusLinePre(line) {
       if (key === 'by') {
         if (MEMORY_ID_RE.test(String(val || ''))) out.supersededBy = String(val)
       } else if (key === 'reason') {
-        const r = String(val || '').replace(/[\r\n]+/g, ' ').trim().slice(0, NOTE_STATUS_REASON_MAX_V1)
+        const r = String(val || '').replace(/[\r\n]+/g, ' ').trim().slice(0, NOTE_STATUS_REASON_MAX_PRE_V1)
         if (r) out.reason = r
       }
     }
@@ -140,7 +140,7 @@ export function statusOfBodyPre(body) {
  */
 export function stripStatusLinePre(body) {
   const s = String(body == null ? '' : body)
-  if (!s.includes(NOTE_STATUS_OPEN_V1)) return s
+  if (!s.includes(NOTE_STATUS_OPEN_PRE_V1)) return s
   // ★ 2026-09-21 bugfix(A-4):原实现 `split(/\r?\n/).join('\n')` 会把**所有** CRLF 改写成裸 LF,
   //   而本函数的调用方 `applyStatusToRecordPre` 作用于**目标条目正文**并回写整篇文档 ⇒
   //   每次 supersedes/retract/restore 都破坏该条目的行尾,与「除状态行外逐字节保持原样」的

package/lib/policies/activation_policy_v2.json

@@ -1,7 +1,7 @@
 {
  "schemaVersion": 1,
- "policyVersion": "activation_policy_v2",
- "parentPolicyVersion": "m7_semantic_threshold_v1",
+ "policyVersion": "activation_policy_pre_v2",
+ "parentPolicyVersion": "m7_semantic_threshold_pre_v1",
  "createdAt": "2026-08-25",
  "runId": "label-review-cal20260824-1954",
  "goldDigest": "e74ccdcda998ae51596adf8119c818ac84fc52a4fa657fd687daeda7d14a072d",