@a9i5k4/dsh-auto-memory 3.1.0 → 3.1.1

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)

package/lib/shadow-host.js

@@ -40,7 +40,30 @@ export function truncateAuditEvent(ev) {
   return e
 }
 
-export function createShadowHost({ engine }) {
+/**
+ * ★P3-9（组2，2026-09-22）：诊断**节流**表。
+ * 原先 `no-paths` 每个 Segment 都直接 console.error ⇒ 单次历史回放能刷出上百行。
+ * 表放**模块级**而非闭包级：同进程多实例共享 ⇒ 不会各自持一份而双写。
+ * 语义同 index.js 的 diagThrottled：首条立即透出，窗口内重复压掉。
+ */
+const DIAG_THROTTLE_MS_V1 = 300000
+const _diagAt = new Map()
+function shouldReportDiag(key) {
+  try {
+    const now = Date.now()
+    if (now - (Number(_diagAt.get(key)) || 0) < DIAG_THROTTLE_MS_V1) return false
+    _diagAt.set(key, now)
+  } catch (_) { /* 计时失败不阻断上报 */ }
+  return true
+}
+
+/**
+ * @param {{engine: object, onDiag?: Function|null, recallStats?: object|null}} opts
+ *   `recallStats` = 召回统计实例（可选）。**依赖注入而非模块级单例**：本模块保持零耦合，
+ *   测试可传假对象（不碰真磁盘）；不传时埋点整段跳过，行为与从前逐字节相同。
+ *   ★命名：不得叫 `stats` —— 本函数内部已有同名 const（shadow 自身计数器），会作用域冲突。
+ */
+export function createShadowHost({ engine, onDiag = null, recallStats = null }) {
   const states = new WeakMap() // runtime → shadow state(lazy)
   const volatileRing = [] // ≤64 events(最小投影)
   const stats = { evaluated: 0, retrieved: 0, prefetched: 0, suppressed: 0, stale: 0, errors: 0 }
@@ -58,6 +81,13 @@ export function createShadowHost({ engine }) {
     engine.config.shadowRetrievalEnabled === true &&
     engine.config.memoryAnchorEnabled === true
 
+  /** ★P3-9（组2）：节流上报。未注入 onDiag 时回落 console.error（保持既有行为，只去掉刷屏）。 */
+  function reportDiag(key, msg) {
+    if (!shouldReportDiag(key)) return
+    if (typeof onDiag === 'function') { try { onDiag(key, msg); return } catch (_) { /* 回落 */ } }
+    try { console.error(msg) } catch (_) {}
+  }
+
   function stateFor(runtime) {
     let st = states.get(runtime)
     if (!st) {
@@ -225,7 +255,7 @@ export function createShadowHost({ engine }) {
           return
         }
         const paths = pathsByKey.get(String(runtime.key || '')) || null
-        if (!paths) { console.error('[shadow-diag] no-paths'); stats.suppressed++; pushVolatile({ reason: 'no-paths-captured', contextVersion: seg.contextVersion }); return }
+        if (!paths) { reportDiag('shadow:no-paths', '[shadow-diag] no-paths'); stats.suppressed++; pushVolatile({ reason: 'no-paths-captured', contextVersion: seg.contextVersion }); return }
         // window:segments ring 最近 8 条(含当前)
         const ringItems = runtime.segments ? runtime.segments.snapshot() : []
         const win = ringItems.slice(-8).map((w) => ({
@@ -320,6 +350,15 @@ export function createShadowHost({ engine }) {
     if (dec.action === 'retrieve') stats.retrieved++
     else stats.prefetched++
     st.recentHits.push({ queryDigest: qp.queryDigest, fresh: ls.kept.length > 0, memoryIds: ls.kept.map((k) => k.memoryId) })
+    // ★③ 召回统计 · shadow 通道（2026-09-22 用户拍板「分开计算」）：
+    //   这条通路 = 系统**主动判断该唤起**，与「模型主动检索」是两回事，必须分账。
+    //   语义：命中率（kept 空 ⇒ 唤起了但没东西）+ 哪些内容被系统认为该唤起。
+    //   ★只读：不改 ls / st / 决策，不影响任何 shadow 行为（守卫断言）。
+    if (recallStats && typeof recallStats.observe === 'function') {
+      try {
+        recallStats.observe(ls.kept.map((k) => ({ id: k.memoryId, layer: k.sourceClass || k.scope || 'shadow' })), { channel: 'shadow' })
+      } catch (_) {}
+    }
     if (st.recentHits.length > 64) st.recentHits.shift()
     st.completedKeys.add(qp.queryDigest + ':' + snapshotOut.memoryIndexVersion)
     if (st.completedKeys.size > 256) { const first = st.completedKeys.values().next().value; st.completedKeys.delete(first) }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@a9i5k4/dsh-auto-memory",
   "description": "Proactive associative memory for DSH: zero-prompt recall injected before the model speaks, three-layer auto-consolidation, skill crystallization, and Astra-style context management - handoff ledgers, PLAN whiteboard, water-level sensing. Local-first, model-agnostic, zero deps. 主动联想记忆+Astra 式上下文管理:自动唤回/自动沉淀/技能固化/交接账本与白板跨窗口续命/水位感知。",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "type": "module",
   "main": "lib/index.js",
   "exports": {