@a9i5k4/dsh-auto-memory 3.1.0 → 3.1.3

package/lib/python-setup.js

@@ -20,7 +20,9 @@ import { promisify } from 'node:util'
 import { createHash } from 'node:crypto'
 import { homedir } from 'node:os'
 import path from 'node:path'
-import { existsSync, mkdirSync, writeFileSync, readFileSync, statSync, createWriteStream } from 'node:fs'
+import { existsSync, mkdirSync, writeFileSync, readFileSync, statSync, createWriteStream, rmSync } from 'node:fs'
+import { Readable } from 'node:stream'
+import { pipeline } from 'node:stream/promises'
 import { readFile, writeFile, rm } from 'node:fs/promises'
 
 const execFileP = promisify(execFile)
@@ -266,32 +268,112 @@ function configReadyForModels() {
     return snapshot()
   }
 
-  /** 断点续传下载:已有 .part 则 Range 续传;完成 8MB 粒度回调进度。 */
-  function downloadWithResume(url, target, onProgress, isCancelled) {
-    return new Promise((resolve, reject) => {
-      const part = target + '.part'
-      let done = 0
-      try { if (existsSync(part)) done = statSync(part).size } catch (_) {}
-      const headers = done > 0 ? { Range: 'bytes=' + done + '-' } : {}
-      fetch(url, { headers }).then((resp) => {
-        if (!resp.ok && resp.status !== 206) { reject(new Error('HTTP ' + resp.status)); return }
-        const total = Number(resp.headers.get('content-length') || 0) + done
-        const stream = createWriteStream(part, done > 0 ? { flags: 'a' } : { flags: 'w' })
-        let lastTick = 0
-        resp.body.on('data', (chunk) => {
-          done += chunk.length
-          const now = Date.now()
-          if (now - lastTick > 500) { lastTick = now; onProgress(done, total) }
-        })
-        resp.body.on('error', (e) => { stream.end(); reject(e) })
-        resp.body.on('end', () => {
-          stream.end(() => {
-            writeFileSyncSafe(part, target).then(resolve).catch(reject)
-          })
-        })
-        dlAbort = () => { try { resp.body.destroy() } catch (_) {} }
-      }).catch(reject)
-    })
+  /**
+   * 断点续传下载（issue #105 重写）。旧实现有三处各自足以致命的点：
+   *
+   * 1. 对 `fetch` 返回的 **WHATWG** `ReadableStream` 调 `.on('data')` / `.destroy()`（那是 Node 流的
+   *    API）⇒ 同步 TypeError 被外层 `.catch(reject)` 吞成一句「下载失败」。**自 v2.1.5 起本档下载从未成功。**
+   * 2. 回调里只累加 `done`，**全程没有 `stream.write()`** ⇒ 即便修好 (1)，目标文件也必然 0 字节。
+   * 3. 无条件 `flags:'a'` 往 `.part` 上追加：既不校验这块 `.part` 属于哪个 URL，也不看服务端是否
+   *    真按 Range 响应 ⇒ 换镜像或服务端忽略 Range 回全量时，两次不同的响应体被拼成同一个文件。
+   *
+   * 现：`Readable.fromWeb` + `pipeline` 真写入；`.part.meta.json` 记归属（url + 已取字节）；未按 206
+   * 续传就丢弃重来；取消走 AbortController（同时传给 `fetch`，断的是连接而不只是本地流）。
+   */
+  async function downloadWithResume(url, target, onProgress, isCancelled) {
+    const part = target + '.part'
+    const metaPath = part + '.meta.json'
+    const bytesOnDisk = () => { try { return existsSync(part) ? statSync(part).size : 0 } catch (_) { return 0 } }
+    const saveMeta = (bytes) => { try { writeFileSync(metaPath, JSON.stringify({ url, bytes, at: Date.now() }), 'utf8') } catch (_) {} }
+    const dropPart = () => { try { rmSync(part, { force: true }) } catch (_) {} try { rmSync(metaPath, { force: true }) } catch (_) {} }
+
+    let done = bytesOnDisk()
+    if (done > 0) {
+      let prevMeta = null
+      try { prevMeta = JSON.parse(readFileSync(metaPath, 'utf8')) } catch (_) {}
+      const mine = !!prevMeta && prevMeta.url === url && Number(prevMeta.bytes) === done
+      if (!mine) {
+        diagOf('[降级] python-setup: .part 不归属本 URL(或缺归属记录)，丢弃 ' + done + ' 字节重下 —— ' + path.basename(target))
+        dropPart()
+        done = 0
+      }
+    }
+    const ac = new AbortController()
+    let aborted = false
+    dlAbort = () => { aborted = true; try { ac.abort() } catch (_) {} }
+    try {
+      let resp = await fetch(url, { headers: done > 0 ? { Range: 'bytes=' + done + '-' } : {}, signal: ac.signal })
+      if (done > 0 && resp.status !== 206) {
+        // 服务端没理 Range（多半回 200 全量）⇒ 追加必然拼出坏文件。丢弃重来，不赌它的内容。
+        diagOf('[降级] python-setup: 服务端未按 Range 响应(status=' + resp.status + ')，丢弃 ' + done + ' 字节 .part 重下')
+        dropPart()
+        done = 0
+        resp = await fetch(url, { headers: {}, signal: ac.signal })
+      }
+      if (!resp.ok && resp.status !== 206) throw new Error('HTTP ' + resp.status)
+      const resumeFrom = done
+      const total = Number(resp.headers.get('content-length') || 0) + resumeFrom
+      let lastTick = 0
+      const src = Readable.fromWeb(resp.body)
+      src.on('data', (chunk) => {
+        done += chunk.length
+        const now = Date.now()
+        if (now - lastTick > 500) { lastTick = now; onProgress(done, total) }
+        if (!aborted && typeof isCancelled === 'function' && isCancelled()) { aborted = true; try { ac.abort() } catch (_) {} }
+      })
+      await pipeline(src, createWriteStream(part, { flags: resumeFrom > 0 ? 'a' : 'w' }))
+      onProgress(done, total)
+      try { rmSync(metaPath, { force: true }) } catch (_) {}
+      await writeFileSyncSafe(part, target)
+      return done
+    } catch (e) {
+      if (aborted || (e && e.name === 'AbortError')) {
+        saveMeta(bytesOnDisk()) // 取消：保留 .part 与归属，下次可续传
+        const err = new Error('已取消'); err.cancelled = true
+        throw err
+      }
+      saveMeta(bytesOnDisk()) // 网络/写盘中断：同样记下归属，避免下次把半截体当可续传块盲拼
+      const err = new Error('下载失败(' + ((e && (e.name || 'Error')) || 'Error') + '): ' + String((e && e.message) || e).slice(0, 160))
+      err.cause = e
+      throw err
+    } finally {
+      dlAbort = null
+    }
+  }
+
+  /**
+   * 完整性校验（issue #105）。声明了 sha256 才真验，且**回读落盘文件**而非累计网络流——
+   * `lib/semantic-js.js:455-459` 记过同族事故：对网络流累积哈希 ⇒ 拼接出来的坏文件照样通过校验。
+   * 未声明 sha256 时不谎称验过：返回 `'size-only'`，由调用方打 `[降级]` 并如实暴露到状态面。
+   */
+  async function verifyArtifact(file, spec = {}) {
+    // 校验失败单独打标：调用方据此**清除正式产物**（见 downloadModel 的 catch）。
+    const bad = (msg) => { const err = new Error(msg); err.integrityFailure = true; return err }
+    const size = statSync(file).size
+    const expected = Number(spec.bytes)
+    if (expected > 0) {
+      if (size !== expected) throw bad('大小不符(' + size + ' ≠ ' + expected + ' bytes): ' + path.basename(file))
+    } else if (spec.minBytes > 0 && size < spec.minBytes) {
+      throw bad('下载不完整(' + size + ' < ' + spec.minBytes + ' bytes): ' + path.basename(file))
+    }
+    const want = typeof spec.sha256 === 'string' ? spec.sha256 : ''
+    if (want.length > 0) {
+      const h = createHash('sha256')
+      await new Promise((res, rej) => {
+        const s = createReadStream(file)
+        s.on('data', (c) => h.update(c))
+        s.on('error', rej)
+        s.on('end', res)
+      })
+      const got = h.digest('hex')
+      if (got !== want) throw bad('sha256 不符(期望 ' + want.slice(0, 12) + '…, 实得 ' + got.slice(0, 12) + '…): ' + path.basename(file))
+      return 'sha256'
+    }
+    if (spec.kind === 'json') {
+      try { JSON.parse(readFileSync(file, 'utf8')) } catch (_) { throw bad('JSON 解析失败: ' + path.basename(file)) }
+      return 'size+json'
+    }
+    return 'size-only'
   }
 
   async function writeFileSyncSafe(from, to) {

package/lib/recall-stats.js

@@ -0,0 +1,242 @@
+/**
+ * 召回统计（recall statistics）—— 只**记录**、不参与排序。
+ *
+ * **为什么只记录**（用户 2026-09-22 拍板的分步走）：
+ *   加权是**会自我强化**的机制（召回越多 → 权重越高 → 越容易被召回）。在埋点口径未被真实数据
+ *   检验之前就加权，会把口径错误放大成系统性偏差。所以本模块**只累积计数并落盘**，
+ *   `recall()` 的排序与返回**逐字节不变**（守卫断言：本模块的调用不改任何排序输入）。
+ *
+ * ★★ 三条通路**分账**，不混为一谈（用户 2026-09-22 明确要求）：
+ *   同一个「召回」在三条通路里的含义完全不同，合成一个数会误导判断：
+ *   | channel  | 含义             | 语义                 | 用来判断什么           |
+ *   |----------|------------------|----------------------|------------------------|
+ *   | `model`  | 模型主动检索     | 「我明确想找」= 高信号 | 什么内容真的有用、被需要 |
+ *   | `inject` | 每轮自动注入     | 「系统一直塞给我」= 成本 | 注入预算花在哪、哪段最费 |
+ *   | `shadow` | 主动唤起（影子） | 「系统觉得该唤起」= 系统判断质量 | 唤起准不准、命中率如何 |
+ *   ⇒ 若把 inject 与 model 合并，会把「模型懒得检索」误读成「这条不重要」，
+ *     而这个误读会被写进加权公式，越滚越偏。故**必须分开存、分开看**。
+ *
+ * 存储：`~/.dsh/memory/recall-stats.json`（单文件、原子写 tmp→rename、有上限裁剪）。
+ * 设计约束：零依赖（只用 node: 内置）＋ fail-soft（统计坏了绝不影响召回本身）。
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, rmSync } from 'node:fs'
+import path from 'node:path'
+
+export const RECALL_STATS_VERSION_PRE = 'recall_stats_v1'
+
+/** 三条通路的稳定 id（写盘/前端都按它索引，禁止改拼写）。 */
+export const RECALL_CHANNELS_PRE = ['model', 'inject', 'shadow']
+
+/** 单条记忆的计数上限（超出按 count 升序淘汰最冷门的，防止文件无限增长）。 */
+const MAX_ENTRIES = 2000
+/** 保留天数（按天分布只留最近 N 天）。 */
+const MAX_DAYS = 90
+
+/**
+ * @param {{file: () => string, now?: () => number}} opts
+ *   `file()` 每次调用都重新解析路径（DSH_HOME 可能变），必须是函数而非字符串。
+ */
+export function createRecallStatsPre(opts = {}) {
+  const nowFn = typeof opts.now === 'function' ? opts.now : () => Date.now()
+  const fileOf = typeof opts.file === 'function' ? opts.file : () => ''
+  let state = null
+  let dirty = false
+
+  const dayOf = (ms) => {
+    const d = new Date(ms)
+    const p = (n) => String(n).padStart(2, '0')
+    return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`
+  }
+  /** 一条通路的空白账本。三条各自独立，互不汇总（汇总只发生在 snapshot 的展示层）。 */
+  const emptyChannel = () => ({
+    events: 0,        // 这条通路发生了多少次（检索次数 / 注入轮数 / 唤起次数）
+    hits: 0,          // 命中条目总数（inject 通道为「注入的条目数」）
+    zeroHit: 0,       // 零命中次数（model 通道专有语义；其它通道记为 0）
+    ids: {},          // id → { count, first, last, layer, score, reason }
+    byLayer: {},      // layer → count
+    byDay: {},        // yyyy-mm-dd → count
+    lastAt: 0,
+  })
+  const empty = () => ({
+    version: RECALL_STATS_VERSION_PRE,
+    since: nowFn(),
+    channels: { model: emptyChannel(), inject: emptyChannel(), shadow: emptyChannel() },
+  })
+
+  /** 兼容旧结构（v1 早期是扁平 queries/hits/byLayer…）→ 迁到 channels.model，不丢数据。 */
+  function migrate(d) {
+    if (d && d.channels && typeof d.channels === 'object') {
+      const base = empty()
+      for (const ch of RECALL_CHANNELS_PRE) {
+        base.channels[ch] = Object.assign(emptyChannel(), (d.channels && d.channels[ch]) || {})
+      }
+      base.since = d.since || base.since
+      return base
+    }
+    const base = empty()
+    const m = base.channels.model
+    m.events = Number(d.queries) || 0
+    m.zeroHit = Number(d.zeroHit) || 0
+    m.ids = (d.hits && typeof d.hits === 'object') ? d.hits : {}
+    m.byLayer = (d.byLayer && typeof d.byLayer === 'object') ? d.byLayer : {}
+    m.byDay = (d.byDay && typeof d.byDay === 'object') ? d.byDay : {}
+    m.hits = Object.keys(m.ids).reduce((n, k) => n + ((m.ids[k] && m.ids[k].count) || 0), 0)
+    m.lastAt = Number(d.lastQueryAt) || 0
+    base.since = d.since || base.since
+    return base
+  }
+
+  function load() {
+    if (state) return state
+    state = empty()
+    try {
+      const f = fileOf()
+      if (f && existsSync(f)) {
+        const d = JSON.parse(readFileSync(f, 'utf8'))
+        if (d && typeof d === 'object' && d.version === RECALL_STATS_VERSION_PRE) {
+          state = migrate(d)
+        }
+      }
+    } catch (_) { state = empty() } // 坏文件不阻塞：从零开始，下一轮覆盖写回
+    return state
+  }
+
+  function save() {
+    if (!dirty) return false
+    try {
+      const f = fileOf()
+      if (!f) return false
+      mkdirSync(path.dirname(f), { recursive: true })
+      const tmp = f + '.tmp'
+      writeFileSync(tmp, JSON.stringify(state), 'utf8')
+      renameSync(tmp, f) // 同目录原子替换
+      dirty = false
+      return true
+    } catch (_) {
+      try { if (fileOf()) rmSync(fileOf() + '.tmp', { force: true }) } catch (_) {}
+      return false
+    }
+  }
+
+  /** 裁剪：**每通道**条目数上限 + 天数上限。按 count 升序淘汰最冷门的。 */
+  function prune() {
+    for (const ch of RECALL_CHANNELS_PRE) {
+      const c = state.channels[ch]
+      if (!c) continue
+      const ids = Object.keys(c.ids)
+      if (ids.length > MAX_ENTRIES) {
+        ids.sort((a, b) => (c.ids[a].count || 0) - (c.ids[b].count || 0))
+        for (const id of ids.slice(0, ids.length - MAX_ENTRIES)) delete c.ids[id]
+      }
+      const days = Object.keys(c.byDay)
+      if (days.length > MAX_DAYS) {
+        days.sort()
+        for (const d of days.slice(0, days.length - MAX_DAYS)) delete c.byDay[d]
+      }
+    }
+  }
+
+  /**
+   * 记一次事件。**只读入参、绝不修改** —— 调用方传的 hits/顺序不因本调用而变。
+   *
+   * ★★ channel 必须显式给：`model`（模型主动检索）/ `inject`（每轮自动注入）/ `shadow`（主动唤起）。
+   *   缺省回落到 `model` 只是为了兼容旧调用点；**新调用点一律显式传**。
+   *
+   * @param {Array<{id:string, layer?:string, score?:number, reason?:string}>} hits
+   * @param {{channel?:'model'|'inject'|'shadow', zero?:boolean, label?:string, chars?:number}} [meta]
+   */
+  function observe(hits, meta = {}) {
+    try {
+      const s = load()
+      const t = nowFn()
+      const ch = RECALL_CHANNELS_PRE.indexOf(meta.channel) >= 0 ? meta.channel : 'model'
+      const c = s.channels[ch]
+      c.events += 1
+      c.lastAt = t
+      const list = Array.isArray(hits) ? hits : []
+      // 零命中：对 model 通道是「检索了但没东西」（重要信号）；其它通道同样计数，语义由展示层解释
+      if (!list.length) c.zeroHit += 1
+      c.hits += list.length
+      const d = dayOf(t)
+      for (const h of list) {
+        const id = h && h.id ? String(h.id) : ''
+        if (!id) continue
+        const cur = c.ids[id] || { count: 0, first: t, last: t, layer: '', score: 0, reason: '' }
+        cur.count += 1
+        cur.last = t
+        if (h.layer) cur.layer = String(h.layer)
+        if (typeof h.score === 'number' && isFinite(h.score)) cur.score = h.score
+        // label / chars：注入侧用来回答「哪一段最占预算」（无 id 的段落用它记账）
+        if (h.__label) cur.reason = String(h.__label)
+        if (typeof h.__chars === 'number' && isFinite(h.__chars)) cur.score = h.__chars
+        if (h.reason) cur.reason = String(h.reason)
+        c.ids[id] = cur
+        const lyr = String(h.layer || 'unknown')
+        c.byLayer[lyr] = (c.byLayer[lyr] || 0) + 1
+        c.byDay[d] = (c.byDay[d] || 0) + 1
+      }
+      prune()
+      dirty = true
+      return true
+    } catch (_) { return false } // fail-soft：统计绝不影响召回
+  }
+
+  /** 把一条通路的账本转成只读视图（已排序，直接可画图）。 */
+  function viewOf(c) {
+    const items = Object.keys(c.ids).map((id) => Object.assign({ id }, c.ids[id]))
+    const top = items.slice().sort((a, b) => b.count - a.count || (b.last || 0) - (a.last || 0))
+    const byLayer = Object.keys(c.byLayer).map((k) => ({ key: k, count: c.byLayer[k] }))
+      .sort((a, b) => b.count - a.count)
+    const byDay = Object.keys(c.byDay).sort().map((k) => ({ day: k, count: c.byDay[k] }))
+    return {
+      events: c.events,
+      hits: c.hits,
+      zeroHit: c.zeroHit,
+      lastAt: c.lastAt,
+      distinct: items.length,
+      top: top.slice(0, 200),
+      byLayer,
+      byDay,
+      warm: top.filter((it) => it.count <= 1).length, // 只出现过一次的（"冷门"候选）
+    }
+  }
+
+  /** 面板/路由用的只读视图。**按通道分组返回**，不做跨通道汇总（汇总口径会误导）。 */
+  function snapshot() {
+    const s = load()
+    const channels = {}
+    for (const ch of RECALL_CHANNELS_PRE) channels[ch] = viewOf(s.channels[ch])
+    return {
+      version: RECALL_STATS_VERSION_PRE,
+      since: s.since,
+      channelIds: RECALL_CHANNELS_PRE.slice(),
+      channels,
+    }
+  }
+
+  /** 复位（面板按钮 / 测试）。 */
+  function reset() {
+    state = empty()
+    dirty = true
+    return save()
+  }
+
+  /**
+   * 注入侧的段级记账（没有条目 id 的段落也能记）。
+   * 用途：回答「哪一段最占注入预算」—— 段名当 id，字符数当 score。
+   * @param {Array<{name:string, chars:number, layer?:string}>} segs
+   */
+  function observeInjection(segs) {
+    const list = (Array.isArray(segs) ? segs : [])
+      .filter((s) => s && s.name)
+      .map((s) => ({
+        id: 'seg:' + String(s.name),
+        layer: s.layer || 'section',
+        score: Number(s.chars) || 0,
+        __label: String(s.name) + ' · ' + (Number(s.chars) || 0) + ' 字符',
+      }))
+    return observe(list, { channel: 'inject' })
+  }
+
+  return { observe, observeInjection, snapshot, reset, save, _load: load, _state: () => state }
+}

package/lib/rules-layer.js

@@ -28,7 +28,14 @@
  *   "模型**真的收到了**"取决于宿主最终请求 messages 的确认（`MASTER-PLAN-3.0.md §7` 的 **U6**，
  *   尚未具备）⇒ **不得**据此宣称"规则的遵守问题已解决"（T7-7 的纪律）。
  *
- * S9 合规：零 IO、零依赖、纯函数、无网络/无 LLM/无子进程/无 await。UTF-8 无 BOM。
+ * S9 合规：零 IO、纯函数、无网络/无 LLM/无子进程/无 await。UTF-8 无 BOM。
+ *
+ * **P9 更新（2026-09-22）**：规则段从此**认状态** —— superseded / retracted 的条目进 retired
+ *   分项、**不再注入**（旧行为是规则段无视状态、过时条目每轮照发）。
+ *   ★**本模块的「零 import」不变式保持不变**：状态解析用**等价内联**（statusOfEntryPre /
+ *   stripStatusLinesPre，语法与 note-status.js 一致），不引入模块依赖。
+ *   理由：p6b 与 p6a 两条守卫都锁这条不变式，且 l0-extract.js:6504-6508 有同样先例；
+ *   等价性由守卫 tests/smoke/smoke-test-p9-rules-lifecycle-pre.mjs 逐例对照断言。
  */
 
 export const RULES_LAYER_VERSION = 'rules_layer_v1'
@@ -70,11 +77,73 @@ export const RULE_DESCRIPTION_MARKERS_V1 = Object.freeze([
 /** 条目切分锚点：与 `l0-extract.js` 的记忆锚点完全一致（不另立一套）。 */
 const MEM_ANCHOR_LINE_RE = /^<!--\s*memory:(mem_[0-9a-f]{32})\s*-->$/
 
-/** 条目内的日期小节（`## 2026-08-14`）——既有记忆文件的实际结构。 */
-const DATE_SECTION_RE = /^##\s*\d{4}-\d{2}-\d{2}\s*$/
+/**
+ * 条目内的日期小节 —— 既有记忆文件的实际结构。
+ *
+ * P9 修正：从「只认 ## + 纯日期」放宽到「任意级别 + 可带标题」——
+ *   旧形态漏掉 `## 2026-09-22 · <标题>` / `### 2026-09-18 · <标题>` 这类带标题的日期小节。
+ */
+const DATE_SECTION_RE = /^#{1,6}\s*\d{4}-\d{2}-\d{2}\s*$/
+
+/** ATX 标题行（任意级别）—— 小节标记，不是规则正文。 */
+const ATX_HEADING_RE = /^#{1,6}\s+(\S.*)$/
+
+/** 标题行的可读文本（剥 # 前缀）—— 正文缺失时的兜底，绝不留空条。 */
+function headingTextPre(line) {
+  const m = ATX_HEADING_RE.exec(clean(line))
+  return m ? m[1].trim() : ''
+}
 
 const clean = (s) => String(s == null ? '' : s)
 
+/**
+ * 条目状态行语法（与 note-status.js **完全一致**；刻意内联见文件头 P9 说明）。
+ * 只认整行、只认三态；非法 memoryId / 未知属性一律丢弃（fail-soft）。
+ */
+const STATUS_LINE_RE_V1 = /^<!--\s*dsh-status:\s*(current|superseded|retracted)\s*((?:\w+=(?:"[^"]*"|[^\s"]+)\s*)*)-->$/
+const STATUS_ATTR_RE_V1 = /(\w+)=(?:"([^"]*)"|([^\s"]+))/g
+const MEM_ID_RE_V1 = /^mem_[0-9a-f]{32}$/
+const STATUS_REASON_MAX_V1 = 120
+
+/**
+ * 从条目正文解析状态：**最后一个**状态行胜出（口径同 note-status.js 的 statusOfBodyPre）。
+ * 无状态行 ⇒ { status: current }。等价性由 tests/smoke/smoke-test-p9-rules-lifecycle-pre.mjs 逐例对照。
+ * @param {string} body 条目正文（不含锚点行）
+ * @returns {{status:string, supersededBy?:string, reason?:string}}
+ */
+export function statusOfEntryPre(body) {
+  const lines = clean(body).split(/\r?\n/)
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const m = STATUS_LINE_RE_V1.exec(lines[i].trim())
+    if (!m) continue
+    const out = { status: m[1] }
+    STATUS_ATTR_RE_V1.lastIndex = 0
+    let a
+    while ((a = STATUS_ATTR_RE_V1.exec(m[2] || '')) !== null) {
+      const k = a[1]
+      const v = a[2] !== undefined ? a[2] : a[3]
+      if (k === 'by') { if (MEM_ID_RE_V1.test(String(v || ''))) out.supersededBy = String(v) }
+      else if (k === 'reason') {
+        const r = String(v || '').replace(/[\r\n]+/g, ' ').trim().slice(0, STATUS_REASON_MAX_V1)
+        if (r) out.reason = r
+      }
+    }
+    return out
+  }
+  return { status: 'current' }
+}
+
+/**
+ * 剥掉**整行**状态行，其余行逐字保留（口径同 note-status.js 的 stripStatusLinePre）。
+ * @param {string} body
+ * @returns {string}
+ */
+export function stripStatusLinesPre(body) {
+  const s = clean(body)
+  if (!s.includes('<!-- dsh-status:')) return s
+  return s.split(/\r?\n/).filter((ln) => STATUS_LINE_RE_V1.exec(ln.trim()) === null).join('\n')
+}
+
 /**
  * 把记忆文本按锚点切成条目（保持既有文件结构语义：无锚点的前置内容归入首条）。
  *
@@ -143,8 +212,8 @@ export function extractRulesLayerPre(input = {}) {
   const o = input && typeof input === 'object' ? input : {}
   const mode = clampMode(o.rulesLayeringMode)
   const empty = {
-    version: RULES_LAYER_VERSION, mode, enabled: false, text: '', rules: [], candidates: [], references: [],
-    counts: { entries: 0, rules: 0, candidates: 0, references: 0 }, chars: { rules: 0, candidates: 0, total: 0 },
+    version: RULES_LAYER_VERSION, mode, enabled: false, text: '', rules: [], candidates: [], references: [], retired: [],
+    counts: { entries: 0, rules: 0, candidates: 0, references: 0, retired: 0 }, chars: { rules: 0, candidates: 0, total: 0 },
   }
   if (mode === null) return empty
 
@@ -161,22 +230,32 @@ export function extractRulesLayerPre(input = {}) {
   const rules = []
   const candidates = []
   const references = []
+  const retired = []
   for (const e of sources) {
-    const c = classifyText(e.text)
-    const rec = { layer: e.layer, id: e.id, anchorLine: e.anchorLine, kind: c.kind, confidence: c.confidence, reasons: c.reasons, text: e.text }
+    // ★P9：先读状态、再分类 —— 状态行是元数据不是正文（留着会被当规则语汇参与分类）
+    const st = statusOfEntryPre(e.text)
+    const content = stripStatusLinesPre(e.text)
+    if (st.status !== 'current') {
+      retired.push({
+        layer: e.layer, id: e.id, anchorLine: e.anchorLine,
+        status: st.status, supersededBy: st.supersededBy || '', reason: st.reason || '',
+        text: content,
+      })
+      continue
+    }
+    const c = classifyText(content)
+    const rec = { layer: e.layer, id: e.id, anchorLine: e.anchorLine, kind: c.kind, confidence: c.confidence, reasons: c.reasons, text: content }
     if (c.kind === 'rule') rules.push(rec)
     else if (c.kind === 'candidate') candidates.push(rec)
     else references.push(rec)
   }
 
   // 规则层文本：只含规则条目（高/中置信），逐条一行摘要，**不掺参考类**
-  const renderLine = (r) => '- ' + ruleSummaryPre(r.text)
-  const parts = []
-  if (rules.length) parts.push(rules.map(renderLine).join('\n'))
-  const text = parts.join('\n')
+  const rowsOut = rules.map((r) => '- ' + ruleSummaryPre(r.text)).filter((s) => s !== '- ')
+  const text = rowsOut.join('\n')
   return {
-    version: RULES_LAYER_VERSION, mode, enabled: true, text, rules, candidates, references,
-    counts: { entries: sources.length, rules: rules.length, candidates: candidates.length, references: references.length },
+    version: RULES_LAYER_VERSION, mode, enabled: true, text, rules, candidates, references, retired,
+    counts: { entries: sources.length, rules: rules.length, candidates: candidates.length, references: references.length, retired: retired.length },
     chars: { rules: text.length, candidates: candidates.reduce((a, r) => a + ruleSummaryPre(r.text).length + 2, 0), total: text.length },
   }
 }
@@ -209,8 +288,16 @@ export function firstLine(text, max = 200) {
  */
 export function ruleSummaryPre(text, max = 200) {
   const lines = clean(text).split('\n').map((l) => l.trim()).filter(Boolean)
+  // ★P9（2026-09-22）：ATX 标题一律视为**小节标记**，优先渲染正文首行；
+  //   正文缺失才回落到标题文本。旧行为把「## <日期> · <标题>」当正文渲染 ⇒
+  //   规则段里进去的全是标题，规则本体一条都不在场（实测 54 条规则多数如此）。
+  let headingFallback = ''
   for (const l of lines) {
     if (DATE_SECTION_RE.test(l)) continue
+    if (ATX_HEADING_RE.test(l)) {
+      if (!headingFallback) headingFallback = headingTextPre(l)
+      continue
+    }
     if (/^<!--/.test(l)) continue
     if (/^[-*+]\s*$/.test(l)) continue
     // 去掉列表前缀再返回，保持一条一行
@@ -218,9 +305,10 @@ export function ruleSummaryPre(text, max = 200) {
     // ★P6B：剥行内 kind 标记与前置时间戳（只影响渲染，不回写盘上原文）
     body = body.replace(LOG_KIND_TAG_RE_V1, ' ').trim()
     body = body.replace(/^\d{1,2}:\d{2}\s+/, '').trim()
+    if (!body) continue
     return body.length > max ? body.slice(0, Math.max(1, max - 1)) + '…' : body
   }
-  return ''
+  return headingFallback.length > max ? headingFallback.slice(0, Math.max(1, max - 1)) + '…' : headingFallback
 }
 
 /**
@@ -241,7 +329,10 @@ export function renderRulesSectionPre(rules, opts = {}) {
   if (!list.length) return { text: '', chars: 0, guide: '' }
   const title = clean((opts && opts.title) || RULES_SECTION_TITLE_V1)
   const guide = clean((opts && opts.guide) || RULES_SECTION_GUIDE_V1)
-  const text = '\n' + title + '\n' + guide + '\n' + list.map((x) => '- ' + ruleSummaryPre(x.text)).join('\n')
+  // ★P9：空摘要**不渲染**（旧写法会产出裸 "- " 行；放宽小节标记后更易出现）
+  const rows = list.map((x) => '- ' + ruleSummaryPre(x.text)).filter((r) => r !== '- ')
+  if (!rows.length) return { text: '', chars: 0, guide: '' }
+  const text = '\n' + title + '\n' + guide + '\n' + rows.join('\n')
   return { text, chars: text.length, guide }
 }
 

package/lib/semantic-js.js

@@ -68,6 +68,22 @@ export function fuseD6Pre(pairs) {
 
 const E5_MODELS_SUBDIR = 'multilingual-e5-small'
 
+/**
+ * ★P3-14（2026-09-22）→ **P10-B 修正（同日晚）**：`artifacts/m7-live-pre/js-semantic-trial` 是**纯维护者机器路径**
+ * （`.gitignore` 已排除其 models/ 与 node_modules/，用户机上结构性不存在）。
+ * P3-14 原用「环境变量 `DAM_DEV_TREE=1` 显式开启」来排除发布包 —— 但那个开关**把维护者本机也一起排除了**
+ * （实测：开发机该目录有 112.8MB 模型 + peer，却因开关默认关而报 `setup-both`）。
+ * ⇒ 改为**存在性判定**：目录存在即视为开发树；用户机上该目录结构性不存在 ⇒ 发布包行为不变。
+ * `DAM_DEV_TREE=1` 保留为**显式强制开启**（离线调试且目录另置时用）。
+ */
+const DEV_TREE_ENABLED = process.env.DAM_DEV_TREE === '1'
+
+/** 开发树 artifacts 候选根（显式开关**或该目录实际存在**时非 null —— 见上方 P10-B 修正）。 */
+function devTreeRoot(pluginDir) {
+  const root = path.join(pluginDir, '..', 'artifacts', 'm7-live-pre', 'js-semantic-trial')
+  return (DEV_TREE_ENABLED || existsSync(root)) ? root : null
+}
+
 function defaultModelsDirCandidates(pluginDir) {
   // 用户目录优先(#15 后续/B 修复):~/.dsh/models/js-semantic/ 跨插件升级存活——
   // 包目录(lib/models)在 npm 更新时会被整体重装,下载的 130MB 模型曾被冲掉。
@@ -76,8 +92,7 @@ function defaultModelsDirCandidates(pluginDir) {
   return [
     path.join(dshHome, 'models', 'js-semantic'),
     path.join(pluginDir, 'models'),
-    path.join(pluginDir, '..', 'artifacts', 'm7-live-pre', 'js-semantic-trial', 'models'),
-  ]
+  ].concat(devTreeRoot(pluginDir) ? [path.join(devTreeRoot(pluginDir), 'models')] : [])
 }
 
 function defaultPeerDirCandidates(pluginDir) {
@@ -87,13 +102,12 @@ function defaultPeerDirCandidates(pluginDir) {
   //   2) <pkg>/node_modules —— 包内邻接位(lib 上 1 级再进 node_modules)
   //   3) lib 上 3 级直拼 @huggingface —— 标准布局即 <root>/node_modules(pnpm hoisted/npm 提升),
   //      pnpm isolated 下即虚拟存储包内位 .pnpm/<hash>/node_modules
-  //   4) 开发树 artifacts
+  //   4) 开发树 artifacts（★P3-14：仅 DAM_DEV_TREE=1 时纳入；该路径 .gitignore 排除、用户机恒不存在）
   return [
     path.join(pluginDir, 'node_modules', '@huggingface', 'transformers'),
     path.join(pluginDir, '..', 'node_modules', '@huggingface', 'transformers'),
     path.join(pluginDir, '..', '..', '..', '@huggingface', 'transformers'),
-    path.join(pluginDir, '..', 'artifacts', 'm7-live-pre', 'js-semantic-trial', 'node_modules', '@huggingface', 'transformers'),
-  ]
+  ].concat(devTreeRoot(pluginDir) ? [path.join(devTreeRoot(pluginDir), 'node_modules', '@huggingface', 'transformers')] : [])
 }
 
 /**
@@ -180,8 +194,12 @@ export function probeJsSemanticAssets(pluginDir, extraDirs, degradedReason) {
   const modelCands = [
     path.join(dshHome, 'models', 'js-semantic', E5_MODELS_SUBDIR, 'onnx', 'model_quantized.onnx'),
     path.join(pluginDir, 'models', E5_MODELS_SUBDIR, 'onnx', 'model_quantized.onnx'),
-    path.join(pluginDir, '..', 'artifacts', 'm7-live-pre', 'js-semantic-trial', 'models', E5_MODELS_SUBDIR, 'onnx', 'model_quantized.onnx'),
-  ]
+  // ★P10-C（2026-09-22，用户裁定）：dev 树闸门从「环境变量显式开启」统一为**存在性判定**。
+  //   P10-B 只改了本文件另外两处（defaultModelsDirCandidates / defaultPeerDirCandidates），
+  //   **探针这处漏改** ⇒ 开发机上 peer 已可解析（面板不再报 setup-both），但资产恒判 missing
+  //   ⇒ 面板显示「JS 引擎模型 ✗ 未就绪」（用户报障）。三处口径现已一致。
+  //   保护意图不变：用户机上 `artifacts/m7-live-pre/` 结构性不存在 ⇒ 发布包行为零变化。
+  ].concat(devTreeRoot(pluginDir) ? [path.join(devTreeRoot(pluginDir), 'models', E5_MODELS_SUBDIR, 'onnx', 'model_quantized.onnx')] : [])
   const modelOnnx = modelCands.find((c) => existsSync(c)) || modelCands[0]
   const assetPresent = existsSync(modelOnnx)
   const peerDir = resolvePeerTransformersDir(pluginDir, extraDirs)