@a9i5k4/dsh-auto-memory 3.0.0 → 3.0.1

package/lib/memory-envelope.js

@@ -191,7 +191,12 @@ export function composeMemoryEnvelopePre(input = {}) {
         })
       } else {
         const before = only.text.length
-        const room = Math.max(1, lim - mark.length)
+        // ★2026-09-20 移植（issue #94③ / PR #100）：预算必须先扣掉同分项内 **must 段**的占用 ——
+        //   旧实现 room = lim − mark 不扣 must ⇒ 超限纯由 must 造成时，对本已放得下的段也追加
+        //   「已截断」标记（越截越长）并注入失实降级说明。
+        const mustChars = bucketTotal(bucket) - only.text.length
+        const available = Math.max(0, lim - mustChars)
+        const room = Math.max(1, available - mark.length)
         only.text = only.text.slice(0, room) + mark
         truncated.push({ bucket, kind: only.kind, charsBefore: before, charsAfter: only.text.length, reason: 'over-limit-truncated' })
         degradations.push({

package/lib/memory-hub.js

@@ -1,4 +1,4 @@
-import { stripRuntimeIntentPre } from './intent-clean-safe.js'
+import { stripRuntimeIntentPre, looksRuntimeResiduePre } from './intent-clean-safe.js'
 import { isObservationOnlyPre } from './procedure-observation.js'
 /**
  * M8-3 Memory Hub 编排器(docs/PROJECT-FREEZE-AND-ROADMAP.md M8/M9; 记忆中枢)。
@@ -51,6 +51,9 @@ export function createMemoryHubPre(opts = {}) {
   const { createEpisodicStorePre } = opts._stores || {}
   const { createFactStorePre } = opts._stores || {}
   const { createProcedureStorePre } = opts._stores || {}
+  // ★T10：机械 procedure 切片开关（默认关闭；缺省值在 index.js 的 DEFAULT_CONFIG）。
+  //   这里只读、不判定语义 —— 具体用途见 crossFeed() 的 procedure 分支。
+  const mechanicalProcedureFeedEnabled = opts.mechanicalProcedureFeedEnabled === true
   const nowFn = typeof opts.now === 'function' ? opts.now : () => Date.now()
   const log = typeof opts.log === 'function' ? opts.log : () => {}
 
@@ -96,10 +99,25 @@ export function createMemoryHubPre(opts = {}) {
         return { consumed: 'procedure', outcome: r.ok ? 'observed' : r.reason }
       }
       if (layer === 'episodic' && stores.episodic) {
-        // episodic_candidate 已是巩固后的 episode,直接喂
-        const r = stores.episodic.restore({ schemaVersion: 1, episodes: [row] })
-        stats.consumedEpisodic++
-        return { consumed: 'episodic', outcome: r.ok ? 'restored' : r.reason }
+        // ★ 2026-09-19 上游 PR #77 / issue #63 同步落地（**P0 数据丢失**）：
+        //   旧实现走 `stores.episodic.restore({schemaVersion:1, episodes:[row]})`，而 `restore()` 是
+        //   **快照整体替换**语义（先清空 episodes）。候选行普遍缺 validateEpisodePre 必填字段
+        //   ⇒ 校验拒（restored:0），**但 episodes 已被清空、current 已置 null**，且仍返回 {ok:true}
+        //   ⇒ 一次 ingest 抹掉全部已巩固 episode，不可逆。
+        //   现改走**增量导入**：不清空、逐条校验、按 episodeId 幂等。
+        //   fallback：老 store 无 importEpisodes 时退化为"不导入"，**绝不回退到 restore**。
+        if (typeof stores.episodic.importEpisodes !== 'function') {
+          stats.skipped++
+          return { skipped: true, reason: 'no-import-episodes' }
+        }
+        const r = stores.episodic.importEpisodes([row])
+        if (r.ok && r.imported > 0) {
+          stats.consumedEpisodic++
+          return { consumed: 'episodic', outcome: 'imported' }
+        }
+        // 如实区分：非法行 / 重复行都不算 consumed（旧实现把两种情况都记成 'restored'）
+        stats.skipped++
+        return { skipped: true, reason: r.duplicates > 0 ? 'duplicate-episode' : 'rejected:' + r.rejected }
       }
     } catch (e) {
       log('memory-hub ingest error: ' + String(e && e.message || e))
@@ -135,7 +153,10 @@ export function createMemoryHubPre(opts = {}) {
       // 而丢失富候选的 successCriteria(晋升永久卡死)。现在显式标 observationOnly=true,
       // 并在 title 前过滤运行时信封(避免注入文本变成技能标题)。
       const procedureIntent = stripRuntimeIntentPre(ep.intent).trim()
-      if (ep.success && stores.procedures && procedureIntent && procedureIntent !== '(未提取)' && ep.actions && ep.actions.length) {
+      // ★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',
@@ -149,9 +170,24 @@ export function createMemoryHubPre(opts = {}) {
       }
       // 有未决事项的 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: ep.intent.slice(0, 30) || 'episode', predicate: '有未决事项',
-          object: ep.unresolved[0].slice(0, 60), sourceKind: 'inference',
+          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)
@@ -198,7 +234,25 @@ export function createMemoryHubPre(opts = {}) {
           .filter((p) => p.stage !== 'active' && p.stage !== 'deprecated')
           // issue #30:如实暴露 observationOnly —— 审批面必须能区分"可晋升技能"与"仅观察线索",
           // 否则使用者会对着一个结构上不可能晋升的条目反复点晋升。
-          .map((p) => ({ procedureId: p.procedureId, title: p.title, stage: p.stage, riskLevel: p.riskLevel, evidence: p.evidence, pinned: !!p.pinned, observationOnly: isObservationOnlyPre(p) })),
+          // ★R2（2026-09-20）：补 `promotion` 判定投影 —— 用户要「晋升原因必须显式展示」。
+          //   走**纯只读**的 evaluatePromotion()，绝不在 overview 里碰 promote()（它写盘）。
+          //   失败时置 null（fail-soft：判定异常不得拖垮整个面板）。
+          .map((p) => {
+            let promotion = null
+            try {
+              promotion = stores.procedures.evaluatePromotion
+                ? stores.procedures.evaluatePromotion(p.procedureId)
+                : null
+            } catch (_) { promotion = null }
+            return {
+              procedureId: p.procedureId, title: p.title, stage: p.stage, riskLevel: p.riskLevel,
+              evidence: p.evidence, pinned: !!p.pinned, observationOnly: isObservationOnlyPre(p),
+              // R4 预览用：晋升后会注入的真实 checklist 文本
+              steps: Array.isArray(p.steps) ? p.steps.slice(0, 12) : [],
+              successCriteria: Array.isArray(p.successCriteria) ? p.successCriteria.slice(0, 6) : [],
+              promotion,
+            }
+          }),
         stats: stores.procedures.getStats ? stores.procedures.getStats() : null,
       } : null,
     }
@@ -236,11 +290,24 @@ export function factCandidateFromRow(row) {
   if (kind !== 'semantic_candidate' && kind !== 'profile_candidate') return null
   const sourceIds = Array.isArray(row.sourceIds) ? row.sourceIds : []
   if (!sourceIds.length) return null
+  // ★ T1-2（2026-09-19 真机追加）：这是 fact 的**第二条入口**（judgement shadow 行），
+  //   与 `crossFeed` 的 fact 分支同源，同样必须过清洗器 —— 否则「补了 A 口、漏了 B 口」，
+  //   脏数据仍会经本函数进入 facts.json（再被 hubFlushTick 写回 MEMORY.md）。
+  //   ★ F5：清洗器按行判断，**行内混信封**时整行保留 ⇒ 再加一道 `looksRuntimeResiduePre`，
+  //   命中即置空（走下面的空值回退），不把半截信封写进库。
+  const rawSubject = String(row.subject == null ? '' : row.subject)
+  const rawPredicate = String(row.predicate == null ? '' : row.predicate)
+  const rawObject = row.object === undefined || row.object === null ? null : String(row.object)
+  const cSubject = looksRuntimeResiduePre(rawSubject) ? '' : stripRuntimeIntentPre(rawSubject).trim()
+  const cPredicate = looksRuntimeResiduePre(rawPredicate) ? '' : stripRuntimeIntentPre(rawPredicate).trim()
+  const cObject = rawObject === null
+    ? null
+    : (looksRuntimeResiduePre(rawObject) ? null : (stripRuntimeIntentPre(rawObject).trim() || null))
   return {
     scope: row.scope === 'User' ? 'User' : 'Workspace',
-    subject: String(row.subject || sourceIds[0]),
-    predicate: String(row.predicate || 'relation'),
-    object: row.object === undefined || row.object === null ? null : String(row.object),
+    subject: cSubject || String(sourceIds[0]),
+    predicate: cPredicate || 'relation',
+    object: cObject,
     sourceKind: 'inference',
     sourceClass: kind === 'profile_candidate' ? 'profile-candidate' : 'semantic-candidate',
     provenance: [...sourceIds],
@@ -267,3 +334,51 @@ export function procedureCandidateFromRow(row) {
     successCriteria: Array.isArray(row.successCriteria) ? row.successCriteria : [],
   }
 }
+
+/**
+ * ④ 教训 → 观察型候选（2026-09-19 R5）。
+ *
+ * **用户裁定（2026-09-18 00:20）**：
+ *   「**教训肯定得进 C 啊，它不自动晋升，但是可以形成候选，模型也可以通过搜索搜索到**。
+ *    因为教训那边，我现在**自动注入的硬约束也是某种教训，把它上升到了约束层面**。」
+ *
+ * **通路设计**：
+ *   `retracted` 条目 + 撤回原因（reason）→ 本函数 → `observationOnly: true` 观察型候选
+ *   → `procedure-store.observe()` → **`promote()` 短路返回 `observation-only` ⇒ 永不自动晋升**
+ *   → 但 `query()` 可检索到 ⇒ 模型能主动搜到「这条曾经被判错、原因是什么」。
+ *
+ * **三条硬约束（缺一即错）**：
+ *  1. **必须 `observationOnly: true`** —— 这是「永不自动晋升」的**唯一结构保证**。
+ *     若漏掉，它会变成可晋升富候选，与用户裁定直接冲突。
+ *  2. **`sourceMemoryIds` 必须带被撤回条目的 id** —— 教训的 provenance 是那条 retracted 记忆本身；
+ *     不得留空（留空会让 `addEvidence` 的 sourceMemoryIds 匹配计数恒零，且与
+ *     episode→观察行 那条通路的语义混淆）。
+ *     注意：这与 `crossFeed()` 里 `sourceMemoryIds: []` 的**有意留空不同** ——
+ *     那里是"episode 只提供线索、不得凭空造 provenance"；这里 id 是**真实存在**的。
+ *  3. **title/intent 必须先过信封清洗** —— 否则运行时信封会再次变成"教训标题"（H-3 同款）。
+ *
+ * @param {{memoryId?: string, title?: string, text?: string, reason?: string, retractedReason?: string}} row
+ * @returns {object|null} procedure candidate（observationOnly），输入不合法返回 null
+ */
+export function lessonCandidateFromRetractedPre(row) {
+  if (!row || typeof row !== 'object') return null
+  const memoryId = String(row.memoryId || '').trim()
+  // 只认严格锚点 id 形态：与 G3 状态行同一套判据（防任意文本被当成 provenance 拼进去）
+  if (!/^mem_[0-9a-f]{32}$/.test(memoryId)) return null
+  const rawTitle = String(row.title || row.text || '').trim()
+  const title = stripRuntimeIntentPre(rawTitle).trim()
+  if (!title) return null
+  const reasonRaw = String(row.reason || row.retractedReason || '').trim()
+  const reason = stripRuntimeIntentPre(reasonRaw).trim().replace(/\s+/g, ' ').slice(0, 120)
+  return {
+    title: ('教训：' + title).slice(0, 60),
+    riskLevel: 'low',
+    // 步骤形态：明说「这是一条教训」+ 撤回原因（原因才是教训的正文）
+    steps: [reason ? ('曾判错，原因：' + reason + '。下次避免：' + title.slice(0, 60)) : ('曾判错：' + title.slice(0, 80))],
+    // ★ 约束 1：永不自动晋升的结构保证
+    observationOnly: true,
+    sourceEpisodes: [],
+    // ★ 约束 2：真实 provenance（非凭空构造）
+    sourceMemoryIds: [memoryId],
+  }
+}

package/lib/memory-index.js

@@ -55,10 +55,12 @@ function decodedLine(buf, s, e) {
 function buildIndex(sourceFile, content, prev) {
   const buf = Buffer.isBuffer(content) ? content : Buffer.from(String(content), 'utf8')
   if (buf.length > INDEX_MAX_FILE_BYTES) {
-    return { sourceFile, fileDigest: '', sourceVersion: (prev && prev.version) || 1, skipped: true, records: [] }
+    // ★2026-09-20 移植（issue #92 / PR #97）：宿主缓存只写 sourceVersion，旧读 prev.version
+  //   在生产路径恒为 undefined ⇒ 版本封顶 2、未变重读回退 1。
+  return { sourceFile, fileDigest: '', sourceVersion: (prev && prev.sourceVersion) || 1, skipped: true, records: [] }
   }
   const fileDigest = createHash('sha256').update(buf).digest('hex')
-  const sourceVersion = prev && prev.fileDigest === fileDigest ? (prev.version || 1) : (prev ? (prev.version || 1) + 1 : 1)
+  const sourceVersion = prev && prev.fileDigest === fileDigest ? (prev.sourceVersion || 1) : (prev ? (prev.sourceVersion || 1) + 1 : 1)
   const lines = splitByteLines(buf)
   const records = []
   let cur = null

package/lib/note-status-apply.js

@@ -0,0 +1,118 @@
+/**
+ * 结论层状态 · **条目级应用**（G3 写盘的核心纯函数）
+ *
+ * 职责：把一条 `status` 落到**指定 memoryId 的条目正文末尾**，返回**新文本**（不写盘）。
+ * 与 `note-status.js` 的分工：
+ *   - `note-status.js` = 状态行的**语法**（渲染/解析/剥离）
+ *   - 本模块            = 状态行的**定位与落点**（在文件里找到那条、放到末尾）
+ *
+ * ── 与既有写入通道的关系（重要）───────────────────────────────
+ * 本模块**不代替** `memory-writer` 事务写入，只产出**新全文**；
+ * 落盘仍由调用方走既有通道（备份/校验/无 BOM 等纪律不绕过）。
+ *
+ * ── 为什么必须「只动目标条目」─────────────────────────────────
+ * MEMORY.md 是**用户可见的明文**且 25+ 锚点共存。任何"顺手重排/格式化"都会：
+ *   ① 让无关条目的 `recordDigest` 变化 ⇒ sidecar sourceVersion 无谓 +1 ⇒ 全量缓存失效；
+ *   ② 制造巨大的 diff，用户在 GUI 里看不出"到底改了什么"。
+ * ⇒ 契约：**除目标条目的状态行外，逐字节保持原样**（含 CRLF 行尾）。
+ *
+ * 纪律：纯函数、零 IO、fail-soft（不改动即返回 null，绝不返回半成品文本）。
+ */
+import { NOTE_STATUS_OPEN_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
+
+/**
+ * 定位一条条目在原文中的**正文区间**。
+ *
+ * 语义与 `parseMemoryItemsPre` 一致：anchor marker **其后**的内容归该条，
+ * 直到**下一个** marker 之前（或文件末尾）。
+ *
+ * @param {string} text 文件全文
+ * @param {string} memoryId
+ * @returns {{start:number, end:number, id:string}|null} 正文的 [start,end) 字符区间
+ */
+export function locateRecordBodyPre(text, memoryId) {
+  try {
+    const src = String(text == null ? '' : text)
+    if (!src || !/^mem_[0-9a-f]{32}$/.test(String(memoryId || ''))) return null
+    ANCHOR_RE.lastIndex = 0
+    const marks = []
+    let m
+    while ((m = ANCHOR_RE.exec(src)) !== null) {
+      // 同时记录 marker 的**真实**起止（不重建字符串 —— 锚点允许空白浮动）
+      marks.push({ id: m[1], start: m.index, end: m.index + m[0].length })
+      if (m.index === ANCHOR_RE.lastIndex) ANCHOR_RE.lastIndex++
+    }
+    for (let i = 0; i < marks.length; i++) {
+      if (marks[i].id !== memoryId) continue
+      const start = marks[i].end
+      // 正文止于**下一个 marker 的起始**（该 marker 及其后内容不属于本条）
+      const end = i + 1 < marks.length ? marks[i + 1].start : src.length
+      return { start, end, id: memoryId }
+    }
+    return null
+  } catch (_) { return null }
+}
+
+/**
+ * ★ 主函数：给指定条目应用状态，返回**新全文**。
+ *
+ * 行为契约：
+ *   - 目标不存在 ⇒ `null`（**fail-soft**：绝不凭空创建条目）
+ *   - `status === 'current'` ⇒ **剥掉**既有状态行（撤销通道；正文其余不变）
+ *   - 已是目标状态且 reason/by 未变 ⇒ 返回**原文**（幂等，调用方可据此跳过写盘）
+ *   - 其余 ⇒ 剥旧状态行 + 在**正文末尾**追加新状态行
+ *   - **行尾风格沿用原文件**（CRLF 保持 CRLF；本仓文件全 CRLF）
+ *   - 任何异常 ⇒ `null`（绝不返回半成品）
+ *
+ * @param {string} text 文件全文
+ * @param {string} memoryId 目标条目
+ * @param {string} status current | superseded | retracted
+ * @param {{supersededBy?:string, reason?:string}} [opts]
+ * @returns {string|null} 新全文；不可应用时为 null
+ */
+export function applyStatusToRecordPre(text, memoryId, status, opts = {}) {
+  try {
+    const src = String(text == null ? '' : text)
+    if (!src) return null
+    const loc = locateRecordBodyPre(src, memoryId)
+    if (!loc) return null
+
+    const seg = src.slice(loc.start, loc.end)
+    // CRLF 感知：本仓文件全 CRLF，必须沿用，否则整文件 diff 爆炸
+    const eol = seg.includes('\r\n') ? '\r\n' : '\n'
+
+    // 先把段落按当前 EOL 归一化切分，处理后再拼回
+    const bodyClean = stripStatusLinePre(seg)
+    const trimmed = bodyClean.replace(/[\r\n\s]+$/, '')
+
+    const line = renderStatusLinePre(status, opts)
+    let next = line ? trimmed + eol + line + eol : (trimmed ? trimmed + eol : '')
+    // 段落与下一个 marker 之间保留一个空行（与既有文件形态一致）
+    next = next ? next + eol : next
+
+    const out = src.slice(0, loc.start) + next + src.slice(loc.end)
+    // 幂等：无变化 ⇒ 返回原文（调用方可据此跳过写盘，避免无谓 sourceVersion +1）
+    return out === src ? src : out
+  } catch (_) { return null }
+}
+
+/**
+ * 只读查询：某条目当前状态（供接线侧判断是否需要写）。
+ * 与 `statusOfBodyPre` 同源，此处补上「文件级」定位。
+ *
+ * @returns {{status:string, supersededBy?:string, reason?:string}|null} 条目不存在 ⇒ null
+ */
+export function readRecordStatusPre(text, memoryId) {
+  try {
+    const src = String(text == null ? '' : text)
+    const loc = locateRecordBodyPre(src, memoryId)
+    if (!loc) return null
+    return statusOfBodyPre(src.slice(loc.start, loc.end))
+  } catch (_) { return null }
+}
+
+/** 供反向锁使用：确认本模块**不碰锚点语法**。 */
+export const NOTE_STATUS_MARKER_V1 = NOTE_STATUS_OPEN_V1

package/lib/note-status.js

@@ -0,0 +1,196 @@
+/**
+ * 结论层状态（G3）· **纯函数核心** —— 零 IO、零副作用、可单测。
+ *
+ * ⚠️ **状态：形态候选，未接线**（2026-09-19）
+ *   本模块只提供**判定与格式**能力；**没有任何调用方**，因此不产生任何写入。
+ *   写盘接线必须等 `G3-DISK-FORMAT-GAP-20260919.md` §4 的 **F1/F2 拍板**后才做：
+ *     F1 = 状态行的磁盘语法；F2 = 「显式声明取代」的模型侧写法。
+ *   理由（误判代价不对称）：漏判 = 维持现状（可接受）；**误判 = 有效结论被当废纸**。
+ *
+ * ── 为什么需要本模块（设计稿未覆盖的缺口）─────────────────────────
+ * `MEMORY-GOVERNANCE-20260917.md` §8.1 断言「地基已存在，只差写入方」。
+ * 实施前核查证明：该断言**只对内存索引列成立**；`status` 的**磁盘表示完全不存在**：
+ *   ① `memory-anchor.js:28` `MARKER_RE` 是**严格锚定** ⇒ 锚点行加不了属性；
+ *   ② 行首含 `MARKER_OPEN` 但不匹配 ⇒ `malformed-anchor` **冲突**（:214）⇒ 写入被拒（storage-manage:181）；
+ *   ③ 全仓**零处**从磁盘读 `status`（`statusOf` 无任何生产者）；
+ *   ④ sidecar 不能承载（`memory-writer.js:434` 明示其为**可重建的派生数据**）。
+ *   ⇒ 必须先定一个**磁盘形态**，这正是 F1 要拍的板。
+ *
+ * ── 形态选择（方案 A/B 已排除，见 GAP 文档 §3）────────────────────
+ *   方案 A（锚点加属性）❌ 撞 ①②，属契约级改动；
+ *   方案 B（独立状态文件）❌ 违反 S10.4「不新建状态源」；
+ *   **方案 C（条目正文内保留行）✅ 采用** —— 状态归条目自身，零语法风险，用户可读。
+ *
+ * ── ★ 关键实现约束：不得污染 L0 ──────────────────────────────────
+ * `extractL0Pre` 规则③（`l0-extract.js:385`）会把**所有非标题行压平**成 L0。
+ * 若状态行留在正文里，无标题条目的 L0 会变成「⚠已作废…」⇒ **检索质量被污染**
+ * （与 M2.5a 修的是同一类问题）。
+ * ⇒ 消费方**必须先 `stripStatusLinePre(body)` 再抽取 L0**，或经 `statusOf` 提供状态。
+ */
+
+/** 状态行开标记。**刻意不复用** `MARKER_OPEN`（`<!-- memory:`）—— 复用会撞锚点契约。 */
+export const NOTE_STATUS_OPEN_V1 = '<!-- dsh-status:'
+
+/**
+ * 状态行语法（F1 候选 (a)：HTML 注释形态）。
+ *
+ * 为什么用 HTML 注释而非裸行 `status: superseded`：
+ *   ① 与仓储既有习俗一致（锚点本身也是 HTML 注释）；
+ *   ② 与正文散文**零碰撞**（裸行会被「正文恰好以 status: 开头」误命中）；
+ *   ③ 渲染后不可见，不干扰人读 Markdown。
+ * 属性值支持裸词与双引号两种写法（reason 含空格时用引号）。
+ */
+const NOTE_STATUS_RE = /^<!--\s*dsh-status:\s*(current|superseded|retracted)\s*((?:\w+=(?:"[^"]*"|[^\s"]+)\s*)*)-->$/
+
+/** 属性解析：`by=mem_xxx` / `reason="含空格 的原因"`。 */
+const NOTE_STATUS_ATTR_RE = /(\w+)=(?:"([^"]*)"|([^\s"]+))/g
+
+/** 只认本仓 id 形态，防把任意文本拼进状态（同 R4-A 的 `supersededMarkPre` 纪律）。 */
+const MEMORY_ID_RE = /^mem_[0-9a-f]{32}$/
+
+/** 三态取值域（与 `l0-extract.js` 的 `L0_STATUSES` 同源；此处独立声明以免循环依赖）。 */
+export const NOTE_STATUSES_V1 = Object.freeze(['current', 'superseded', 'retracted'])
+
+/** reason 上限：状态行是**元数据**不是正文，超长即视为脏数据。 */
+export const NOTE_STATUS_REASON_MAX_V1 = 120
+
+/**
+ * 渲染状态行（**纯函数**）。
+ *
+ * `current` ⇒ 返回 `''`（**当前态无需落盘**：缺失即默认 current，少写字节、少一处漂移源）。
+ * 未知 status / 非法 id ⇒ 返回 `''`（**fail-closed**：宁可不写，绝不写错 —— 与消费侧同纪律）。
+ *
+ * @param {string} status current | superseded | retracted
+ * @param {{supersededBy?:string, reason?:string}} [opts]
+ * @returns {string} 状态行（含 `\n` 时不带）；不可渲染时为空串
+ */
+export function renderStatusLinePre(status, opts = {}) {
+  try {
+    if (status !== 'superseded' && status !== 'retracted') return ''
+    let line = NOTE_STATUS_OPEN_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)
+      : ''
+    if (reason) line += ' reason="' + reason.replace(/"/g, "'") + '"'
+    return line + ' -->'
+  } catch (_) { return '' }   // fail-soft：渲染失败绝不抛（与 supersededMarkPre 同纪律）
+}
+
+/**
+ * 解析单行状态。非状态行 ⇒ `null`（不抛、不猜）。
+ *
+ * 返回对象**只含合法字段**：非法 `by` 被丢弃（不写进结果），未知属性忽略。
+ *
+ * @param {string} line 单行文本
+ * @returns {{status:string, supersededBy?:string, reason?:string}|null}
+ */
+export function parseStatusLinePre(line) {
+  try {
+    const s = String(line == null ? '' : line).trim()
+    if (!s) return null
+    const m = NOTE_STATUS_RE.exec(s)
+    if (!m) return null
+    const out = { status: m[1] }
+    NOTE_STATUS_ATTR_RE.lastIndex = 0
+    let a
+    while ((a = NOTE_STATUS_ATTR_RE.exec(m[2] || '')) !== null) {
+      const key = a[1]
+      const val = a[2] !== undefined ? a[2] : a[3]
+      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)
+        if (r) out.reason = r
+      }
+    }
+    return out
+  } catch (_) { return null }
+}
+
+/**
+ * 从**条目正文**解析状态。
+ *
+ * 语义：**最后一个**状态行胜出（后写覆盖先写 —— 状态是"当前值"不是"历史轨迹"）。
+ * 无状态行 ⇒ `{status:'current'}`（与索引层「缺失即默认」口径完全一致）。
+ *
+ * @param {string} body 条目正文（不含锚点行）
+ * @returns {{status:string, supersededBy?:string, reason?:string}}
+ */
+export function statusOfBodyPre(body) {
+  const s = String(body == null ? '' : body)
+  const lines = s.split(/\r?\n/)
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const hit = parseStatusLinePre(lines[i])
+    if (hit) return hit
+  }
+  return { status: 'current' }
+}
+
+/**
+ * 剥掉状态行，返回**可安全送往 L0 抽取**的正文。
+ *
+ * ★ 这是本模块存在的主要理由之一：不剥 ⇒ 无标题条目的 L0 会被状态行污染（见文件头注释）。
+ * 纪律：只删**整行**匹配的；行内出现（如正文引用该语法）**保持原样**交由
+ * `checkReservedSyntaxInContent` 一类守卫处理，本函数不做静默改写。
+ *
+ * @param {string} body
+ * @returns {string}
+ */
+export function stripStatusLinePre(body) {
+  const s = String(body == null ? '' : body)
+  if (!s.includes(NOTE_STATUS_OPEN_V1)) return s
+  return s.split(/\r?\n/).filter((ln) => parseStatusLinePre(ln) === null).join('\n')
+}
+
+/**
+ * 追加状态行到正文末尾（**纯函数**，不写盘）。
+ *
+ * 约束（见文件头）：
+ *   - 先剥旧状态行 ⇒ 结果是**幂等**的（同参数重复调用不叠加）；
+ *   - 只追加在**末尾**，绝不前置（前置会污染 L0 规则②/③）；
+ *   - `current` ⇒ 只剥不写。
+ *
+ * @param {string} body
+ * @param {string} status
+ * @param {{supersededBy?:string, reason?:string}} [opts]
+ * @returns {string}
+ */
+export function withStatusLinePre(body, status, opts = {}) {
+  const base = stripStatusLinePre(body).replace(/[\r\n\s]+$/, '')
+  const line = renderStatusLinePre(status, opts)
+  if (!line) return base
+  return base + '\n' + line
+}
+
+/**
+ * ★F2 候选 (b)：从**正文**识别「显式声明取代」。
+ *
+ * ⚠️ 本函数**未接线**，且**不建议作为首个版本的唯一通路**：
+ *   用户裁定的门槛是「**(a) 只认显式声明**」，而**结构化参数**（F2 候选 a）才是最纯的显式声明；
+ *   从自然语言里正则识别**必然**存在误判，与「宁可漏判不可误判」冲突。
+ *   保留它用于：(b)/(c) 落地时作为**第二通路**，或作为「M2 lint 只报告」的输入。
+ *
+ * 判据（**双条件**，缺一不可 —— 这是保守性的关键）：
+ *   ① 出现取代**动作词**（取代/替换/作废/推翻/废弃 supersede）/ 或显式参数；
+ *   ② 同时出现**合法 memoryId**。
+ *   仅命中其一 ⇒ 返回 `null`（**只报告不标**）。
+ *
+ * @param {string} content 新写入的正文
+ * @returns {{target:string, evidence:string}|null}
+ */
+export function detectSupersedeIntentPre(content) {
+  try {
+    const s = String(content == null ? '' : content)
+    if (!s) return null
+    const ACT_RE = /(取代|替换|作废|废弃|推翻|supersede[sd]?|replaces?)/i
+    const ID_RE = /mem_[0-9a-f]{32}/g
+    const ids = s.match(ID_RE)
+    if (!ids || !ids.length) return null
+    if (!ACT_RE.test(s)) return null
+    // 去重保序；多目标时**不自动全标**（保守），交调用方逐个确认
+    const uniq = [...new Set(ids)]
+    return { target: uniq[0], evidence: (s.match(ACT_RE) || [''])[0] }
+  } catch (_) { return null }
+}