npm - @a9i5k4/dsh-auto-memory - Versions diffs - 3.0.0 → 3.1.0 - Mend

@a9i5k4/dsh-auto-memory 3.0.0 → 3.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (116) hide show

package/README.md +30 -13
package/README.zh-CN.md +30 -13
package/docs/FRONTEND-CO-CREATION.md +191 -0
package/docs/GM53-HOMEPAGE-PROMPT.md +323 -0
package/docs/HANDBOOK.md +88 -52
package/docs/HOMEPAGE-CONTENT-FOR-GM53.md +299 -0
package/docs/PROMO-PROMPT-3.0.md +100 -0
package/docs/USER-GUIDE.en.md +11 -11
package/docs/USER-GUIDE.zh-CN.md +11 -11
package/docs/WHITEPAPER.md +207 -0
package/docs/screenshots/promo/promo-0-banner-v3.png +0 -0
package/docs/screenshots/promo/promo-0-banner-v4.png +0 -0
package/docs/screenshots/promo/promo-1b-auto-recall.png +0 -0
package/lib/activation-host.js +69 -10
package/lib/board-mode.js +1 -1
package/lib/client.js +1697 -285
package/lib/config-io.js +156 -0
package/lib/context-bridge.js +3 -0
package/lib/context-host.js +23 -10
package/lib/degrade.js +385 -0
package/lib/dsh-home.js +143 -0
package/lib/episodic-store.js +142 -18
package/lib/evidence-store.js +8 -1
package/lib/fact-store.js +484 -43
package/lib/hub-io.js +217 -0
package/lib/index-sync.js +13 -1
package/lib/index.js +1730 -202
package/lib/intent-clean-safe.js +258 -40
package/lib/l0-extract.js +231 -16
package/lib/m4-corpus.js +8 -2
package/lib/m7-index-sync-host.js +8 -1
package/lib/memory-envelope.js +6 -1
package/lib/memory-hub.js +164 -17
package/lib/memory-index.js +4 -2
package/lib/note-status-apply.js +118 -0
package/lib/note-status.js +204 -0
package/lib/procedure-store.js +333 -31
package/lib/procedure-switch.js +38 -0
package/lib/python-sidecar-client.js +314 -11
package/lib/recall-fusion.js +83 -12
package/lib/rules-edit.js +159 -0
package/lib/semantic-decide.js +41 -8
package/lib/semantic-js.js +51 -6
package/lib/shadow-host.js +3 -5
package/lib/skill-export-host.js +153 -0
package/lib/skill-export.js +239 -0
package/lib/storage-manage.js +6 -0
package/lib/temporal-parse.js +191 -159
package/lib/tier0-catalog.js +45 -3
package/lib/wb-contract.js +198 -2
package/lib/wb-sidecar.js +54 -3
package/package.json +6 -2
package/docs/internal/ACCEPT-35-LIVE.md +0 -143
package/docs/internal/ACCEPTANCE-20260914.md +0 -90
package/docs/internal/ARCH-REVIEW-BRIEF.md +0 -411
package/docs/internal/ARCH-REVIEW-REQUEST.md +0 -201
package/docs/internal/ARCH-REVIEW-ROUND2.md +0 -169
package/docs/internal/ARCH-REVIEW-ROUND3.md +0 -206
package/docs/internal/ART-DIRECTION-WIREFRAME.md +0 -181
package/docs/internal/AUDIT-WB-GRAPH-FULL-20260916.md +0 -314
package/docs/internal/CONCURRENCY-INVESTIGATION-20260917.md +0 -192
package/docs/internal/CROSS-SESSION-SEARCH-PATH-DECISION.md +0 -72
package/docs/internal/CROSS-SESSION-SEARCH-RESEARCH.md +0 -131
package/docs/internal/CUA-VISION-FIX-NOTES.md +0 -78
package/docs/internal/DECISIONS-20260914-SESSION.md +0 -269
package/docs/internal/DESIGN-OVERHAUL-PRE-RESEARCH.md +0 -292
package/docs/internal/DESIGN-P1-STATE-COMMIT-20260915.md +0 -219
package/docs/internal/DIRECTION-CHECK-WB-GRAPH-20260916.md +0 -132
package/docs/internal/FEEDBACK-TO-DSHAPI-RELAY.md +0 -13
package/docs/internal/GH-DISCUSSION-5732-COMMENT.md +0 -74
package/docs/internal/GPT-ACCEPTANCE-PROMPT-20260916.md +0 -352
package/docs/internal/GPT-REVIEW-PROMPT.md +0 -216
package/docs/internal/GROUP-DIGEST-SETUP.md +0 -62
package/docs/internal/GROUP-LISTENER-SETUP.md +0 -49
package/docs/internal/GROUP-WEBHOOK-SETUP.md +0 -93
package/docs/internal/HANDOFF-TO-ZCODE.md +0 -168
package/docs/internal/KICKOFF-P0.md +0 -254
package/docs/internal/MASTER-PLAN-3.0.md +0 -411
package/docs/internal/MEMORY-MUTATION-AND-INDEX-DESIGN.md +0 -85
package/docs/internal/MERGE-CONFLICT-SCAN-20260914.md +0 -222
package/docs/internal/NEXT-VERSION-TODO.md +0 -95
package/docs/internal/OFFICIAL-DISCUSSION-DRAFT.md +0 -80
package/docs/internal/PENDING-FIXES-20260916.md +0 -289
package/docs/internal/RAG-KARPATHY-PROGRAM.md +0 -229
package/docs/internal/RELEASE-PROCESS.md +0 -99
package/docs/internal/REPORT-P0-NIGHTLY.md +0 -212
package/docs/internal/REPORT-P5-ACCEPTANCE.md +0 -31
package/docs/internal/REPORT-WB-GRAPH-NIGHTLY.md +0 -153
package/docs/internal/REVIEW-WB-GRAPH-SELF.md +0 -81
package/docs/internal/ROADMAP-20260917-WEEK.md +0 -305
package/docs/internal/ROADMAP.md +0 -106
package/docs/internal/RUN-P0-NIGHTLY.md +0 -227
package/docs/internal/S10-CONSTRUCTION-HANDOFF-20260917.md +0 -175
package/docs/internal/S10-GAPS-PLAIN-20260917.md +0 -125
package/docs/internal/SEMANTIC-ARCHITECTURE-SPEC.md +0 -360
package/docs/internal/SESSION-FILE-REPAIR-PROTOCOL.md +0 -90
package/docs/internal/SUBAGENT-REPORT-ROUTING-PRE-RESEARCH.md +0 -261
package/docs/internal/THREE-LAYER-CONTRACT.md +0 -210
package/docs/internal/TODO-BACKLOG.md +0 -263
package/docs/internal/TODO-GRAPH.html +0 -715
package/docs/internal/TODO-GRAPH.html.bak-20260914-v2 +0 -493
package/docs/internal/TODO-GRAPH.html.bak-20260915-alsfix +0 -710
package/docs/internal/TODO-GRAPH.html.bak-20260915-p1 +0 -710
package/docs/internal/TODO-GRAPH.html.bak-20260915-p6a-rev +0 -703
package/docs/internal/TODO-GRAPH.html.bak-20260915-wshint +0 -710
package/docs/internal/TODO-GRAPH.html.bak-20260916-batch +0 -715
package/docs/internal/WB-FORMAT-CONVENTION.md +0 -112
package/docs/internal/WB-GRAPH-DECISIONS-20260914.md +0 -71
package/docs/internal/WB-GRAPH-INTEGRATION-PLAN.md +0 -386
package/docs/internal/WB-GRAPH-RESEARCH-BRIEF.md +0 -118
package/docs/internal/WB-GRAPH-RESEARCH-EXTERNAL.md +0 -228
package/docs/internal/WB-GRAPH-RESEARCH-LOCAL.md +0 -190
package/docs/internal/reviews/CLAIM-VERIFICATION-20260914.md +0 -56
package/docs/internal/reviews/PLAN-gpt6astra-round2-20260914.md +0 -787
package/docs/internal/reviews/REVIEW-gpt6astra-20260914.md +0 -112
package/docs/internal/reviews/ROUND3-REVIEW-INTEGRATION-20260914.md +0 -230

package/lib/intent-clean-safe.js CHANGED Viewed

@@ -1,40 +1,258 @@
-/** Remove runtime envelopes only at unquoted line boundaries; preserve literal examples/code. */
-const tags = new Set(['memory_system', 'system-reminder', 'long_term_memory'])
-export function stripRuntimeIntentPre(text) {
-  const lines = String(text == null ? '' : text).split(/\r?\n/)
-  const out = [], stack = []
-  let fence = null
-  for (let line of lines) {
-    const trimmed = line.trim()
-    if (!stack.length) {
-      const f = /^( {0,3})(`{3,}|~{3,})/.exec(line)
-      if (f) {
-        if (!fence) fence = { char: f[2][0], size: f[2].length }
-        else if (f[2][0] === fence.char && f[2].length >= fence.size && /^( {0,3})(`+|~+)\s*$/.test(line)) fence = null
-        out.push(line); continue
-      }
-      if (fence || /^\s*>/.test(line) || /^ {4}/.test(line)) { out.push(line); continue }
-      if (/^(?:current runtime context\.|current dsh file policy:)/i.test(trimmed)) continue
-    }
-    // Consume one or more envelopes at the beginning of an unquoted line.
-    // Closing tags can end a prefix split across messages; trailing human text is retained.
-    for (;;) {
-      if (stack.length) {
-        const token = /<(\/?)(memory_system|system-reminder|long_term_memory)>/.exec(line)
-        if (!token) { line = ''; break }
-        line = line.slice(token.index + token[0].length)
-        if (!token[1]) stack.push(token[2])
-        else if (stack[stack.length - 1] === token[2]) stack.pop()
-        continue
-      }
-      const open = /^\s*<(memory_system|system-reminder|long_term_memory)>/.exec(line)
-      if (open && tags.has(open[1])) { stack.push(open[1]); line = line.slice(open[0].length); continue }
-      const close = /^\s*<\/(memory_system|system-reminder|long_term_memory)>/.exec(line)
-      if (close) { line = line.slice(close[0].length); continue }
-      break
-    }
-    if (line.trim()) out.push(line)
-    else if (!stack.length && !trimmed) out.push('')
-  }
-  return out.join('\n')
-}
+/**
+ * 运行时信封剥离器 —— **结构判据版**（2026-09-19 R5）。
+ *
+ * 只在未被引用/未被代码块包裹的行上剥离信封；保护字面示例与代码块。
+ *
+ * ★ 本次改动的根因（issue #30 / ③ Hermes 遗留 / H-3）：
+ *   旧实现在 `:17` 用**一条字面量行首白名单** `/^(?:current runtime context\.|current dsh file policy:)/i`
+ *   识别信封 ⇒ 只能挡住两个当期已知形态。真机取证（`~/.dsh/memory/hub/procedures.json`，
+ *   10 条 procedure 里 7 条 observed、其中 4 条 title 就是运行时信封）实测漏网 4 类：
+ *     · `Approval prompts are disabled in this session: …`
+ *     · `{"path":"D:\\…`（工具回包的 JSON 转储）
+ *     · 中文「当前运行时上下文。」
+ *     · 自然语言「消息系统提醒由框架…」
+ *   ⇒ 这正是本文件旧注释自己预警的风险：「注入形态会演进 ⇒ 漏判」。
+ *
+ * ★ 修法（**形态侦测，不是再添几条文法**）：信封的共同**结构性质**有二，不依赖具体措辞——
+ *   **F1 结构化转储**：以 `{`/`[` 开头且以 `}`/`]` 收尾的行 = 工具回包的 JSON，永不可能是人的输入；
+ *   **F2 声明头 + 分隔符**：`<head noun>[:：.。] <说明>` 形状，且 head noun 落在
+ *       **harness 自有词汇族**内（runtime/approval/policy/sandbox/session/permission/escalation/…）。
+ *       注意判据是「**族**（family）+ 形状」，不是整句前缀 ⇒ 框架换措辞（"Approval prompts…" →
+ *       "Escalation is handled by…"）仍能被同一个族覆盖。
+ *   F2 额外加**位置约束** `leadingOnly`：仅对消息**开头的信封区**生效（一旦出现真人文本即停止），
+ *   因为 harness 一律把元数据注入在头部；这条把误伤面压到接近零（正文里写 "Policy: xxx" 不会被删）。
+ *
+ * 三条形态族之外的未知形态仍会漏 —— 这是**形态侦测的固有边界**，故本模块只保证：
+ * ①已知族全覆盖；②族内可扩展（加词族 ≠ 加整句前缀）；③漏判只会让**噪音**进入 intent，
+ * 不会把真人问题删掉（真人文本一旦出现即关闭 F2 位置约束）。
+ */
+/** 被识别的信封标签名（闭包内使用，声明必须在本文件任何使用者之前）。 */
+const tags = new Set(['memory_system', 'system-reminder', 'long_term_memory'])
+/** 行首精确信封前缀（向后兼容，任意位置生效）。 */
+const EXACT_ENVELOPE_RE = /^(?:current runtime context\.|current dsh file policy:)/i
+/**
+ * F2 英文声明头词族。
+ *
+ * ★ 2026-09-19 真机取证补第二形态：title 会被**截断到 40 字符**，
+ *   本机的 `Approval prompts are disabled in this se` 连冒号都被截掉了 ⇒ 只靠「分隔符」判据会漏。
+ *   故补 `BE_STATEMENT_RE`（词族开头 + be 动词陈述句），它同样不依赖整句字面量：
+ *   框架换措辞（"Approval prompts…" → "Escalation prompts are handled…"）仍在族内。
+ */
+const HARNESS_HEAD_RE = /^(?:current|approval|approvals|sandbox|policy|policies|runtime|session|permission|permissions|escalation|tools?|files?|memory)\b[^.!?\n]{0,90}[:：.。]/i
+/** F2 第二形态：词族开头 + be 动词系表结构（截断后仍成立）。 */
+const BE_STATEMENT_RE = /^(?:current|approval|approvals|sandbox|policy|policies|runtime|session|permission|permissions|escalation)\b[^.!?\n]{0,60}\b(?:is|are|was|were|has been|have been|will be)\b/i
+/** F2 中文声明头词族（对应上方英文族）。 */
+const HARNESS_HEAD_ZH_RE = /^(?:当前|批准|沙箱|策略|运行时|会话|权限|升级|工具|文件|记忆)[^。！？\n]{0,50}[:：。]/
+/**
+ * F3 插件自产注入标记（★ 2026-09-19 真机取证新增）。
+ *
+ * **发现过程**：⑨ 探针逐条检验真机 `procedures.json` 的 11 条 title，
+ * 发现**时间戳最新的一条**（2026-09-19）title 是 `[Retrieved memory refe` ——
+ * 它正是**本插件自己注入的「记忆召回」块标记**
+ * （`activation-inbox.js:58` 的 `TAIL_MARKER_LINE_V1`）。
+ *
+ * ⇒ **自污染闭环**：插件注入召回块 → 召回块随 userText 进 episode →
+ *   `crossFeed()` 把它当成技能 title ⇒ 又回到「技能审批队列」。
+ * ⇒ 且它**仍在持续产生**（非历史存量），故必须修，不能只清数据。
+ *
+ * **判据仍是词族 + 行首位置**（不写整句字面量，故标记措辞微调后仍成立）：
+ *   ① `[Retrieved memory ref…` —— 允许被 `slice(0,40)` 截断，**不要求闭合方括号**
+ *   ② `Verify against the current user request…` —— 召回块尾部校验行
+ *   ③ `If a reference hints at what you need…` —— 召回块尾部取用提示行
+ *   ④ `Source: mem_<32hex>` —— 召回条目的来源行（结构化形态，散文不会这样起行）
+ *
+ * 位置：与 F1/`EXACT_ENVELOPE_RE` 同属**任意位置生效**（召回块可出现在文本中段）。
+ * `^` 锚定保证不误伤引用该标记的句子（如「解释一下 [Retrieved memory…」不会以它开头）。
+ */
+const PLUGIN_TAIL_MARKER_RE = /^\[?Retrieved memory ref|^Verify against the current user request|^If a reference hints at what you need|^Source:\s*mem_[0-9a-f]{32}|^Reason:\s*fv2 lane=|^Score:\s*[0-9.]+ \(rank \d+\/\d+\)/i
+/**
+ * F3-补（★ 2026-09-19 T1-0 真机追加）：召回块的**块身份锚**与**弱标记行**。
+ *
+ * **漏网根因（实测）**：`PLUGIN_TAIL_MARKER_RE` 里的 `^Source:\s*mem_[0-9a-f]{32}` 把
+ * 「前缀」与「后缀内容」**绑死** ⇒ 一旦该行被 `slice(0, N)` 截断（`Source: mem_…` → `Source: me`），
+ * 判据立即失效；且 F3 **完全没有 `^Reference:` 这一条**，而 `renderItemBlock`
+ * （`activation-inbox.js:223`）每块都会输出一行 `Reference: …` ⇒ 该行**必然幸存**并成为
+ * `extractIntent`（`episodic-store.js:167`）的输入 ⇒ 变成技能标题。
+ * 真机后果：`pipeline` 从 3 条涨回 5 条，新增 `Source: me` 与 `Reference: ## 2026-09-18 - dsh-auto-memo`。
+ *
+ * **修法（族 + 形状，不再绑死后缀）**：拆成两级，避免为堵漏而误伤真人引用句
+ * （`⑨` 套件 [4] 组用字面量锁定了「`Source: mem_xxx 这个格式对不对？` 必须保留」）：
+ *   ① `PLUGIN_BLOCK_ANCHOR_RE` —— **强标记**：散文不可能这样起行，单条即可确立「这是召回块」；
+ *   ② `PLUGIN_BLOCK_LINE_RE` —— **弱标记**：`Source:` / `Reference:` 行的**后缀内容任意**
+ *      （可能是被截断的 id、记忆正文、甚至 markdown 标题），故**只在①已确立块身份时**才生效。
+ * 这样「整块召回」被完整清空，而**孤立的 `Source:` 句子不受影响**。
+ */
+const PLUGIN_BLOCK_ANCHOR_RE = /^\[?Retrieved memory ref|^Verify against the current user request|^If a reference hints at what you need|^Reason:\s*fv2 lane=|^Score:\s*[0-9.]+ \(rank \d+\/\d+\)|^Source:\s*mem_[0-9a-f]{32}/i
+/** F3 弱标记：仅当同一段文本已被 `PLUGIN_BLOCK_ANCHOR_RE` 确立为召回块时才参与判定。 */
+const PLUGIN_BLOCK_LINE_RE = /^Source:\s*\S|^Reference:\s*\S/i
+/**
+ * F3 截断残片：整行只剩「标签 + 单个裸 token」。
+ *
+ * `Source: me` 正是 `Source: mem_<32hex>` 被截到 10 字符的产物。真人的引用句必带后续文字
+ * （如 `Source: mem_xxx 这个格式对不对？` 含空格与整句），故用「**无块上下文也能单独判定**」这条
+ * 只需一个约束即可安全覆盖：`\S+` 后**必须直接行尾**（不允许空格续文）。
+ */
+const PLUGIN_TRUNCATED_FRAGMENT_RE = /^Source:\s*\S+\s*$/i
+/**
+ * F3 `Reference:` + markdown 标题 —— **插件指纹，可单独判定**。
+ *
+ * `renderItemBlock`（`activation-inbox.js:223`）写的是 `'Reference: ' + refText`，
+ * 而 `refText` 来自 L0 记录正文（以 `## <标题>` 起头）⇒ 该行必然是 `Reference: ## …` 形状。
+ * 真人几乎不可能写出「`Reference:` 紧跟 `##`」，故这一条不需要块上下文。
+ * （实测漏网样本：`Reference: ## 2026-09-18 - dsh-auto-memory 项目铁律:fail-soft/降级`）
+ */
+const PLUGIN_REF_HEADING_RE = /^Reference:\s*#{1,6}\s+\S/i
+/**
+ * F4 编码损坏行（★ 2026-09-19 真机取证新增）。
+ *
+ * 真机存在一条 title 为 `\ufffd\ufffd…正确（验证）`（U+FFFD 替换字符堆叠）——
+ * 是**编码损坏**（非 UTF-8 字节被强行解码）的产物，属结构性垃圾，不可能是有意义标题。
+ * 判据：替换字符 ≥3 个（单/双个可能出现在正常文本中，不作判据）。
+ */
+function looksEncodingCorruptedPre(trimmed) {
+  return (trimmed.match(/\ufffd/g) || []).length >= 3
+}
+/**
+ * F5 行内运行时残留（★ 2026-09-19 T1-3 真机追加）。
+ *
+ * **发现过程**：新套件 [6] 组跑出一条 FAIL —— 真机 fact[1] 的 object 是
+ *   `现在是什么情况？ Current DSH file policy: danger-full-access. The DS`
+ *   └─真人话─┘└──────────────── 运行时信封 ────────────────┘
+ * 即**真人与信封挤在同一行**。
+ *
+ * **为什么清洗器处理不了它**：`stripRuntimeIntentPre` 是**按行判断**的 ——
+ * 删掉这样的整行会**连带丢掉真人话**（「现在是什么情况？」），所以它必须保留。
+ * ⇒ 「清洗后是否变化」这条判据对**行内混合**天然无效。
+ *
+ * **所以本判据是给「写入侧卫生门」用的**（`hubFlushTick`）：
+ * 它不负责清洗，只负责回答「这条文本里还有没有运行时痕迹」⇒ 有则 skip。
+ * 同样用于 fact 通路：行内混信封的 subject/object 不该进正文。
+ *
+ * 判据是**标记短语**（任意位置），不要求行首 —— 这正是它区别于 F1/F2 的地方：
+ * F1/F2 判「整行是信封」，F5 判「行内夹带信封」。
+ */
+const RUNTIME_RESIDUE_RE = /Current DSH file policy|Current runtime context|Approval prompts are disabled in this session|\[Retrieved memory ref|Verify against the current user request|If a reference hints at what you need|Reason:\s*fv2 lane=|Score:\s*[0-9.]+ \(rank \d+\/\d+\)|^\s*(?:Reference|Source|Reason)\s*:\s*-\s*\d{1,2}:\d{2}\s*\[kind:|^\s*\d{1,2}:\d{2}\s*\[kind:[a-z]+\]|^\s*\[kind:[a-z]+\]/im
+/** F5：行内是否夹带运行时信封痕迹（不做清洗，只做判定）。 */
+export function looksRuntimeResiduePre(text) {
+  return RUNTIME_RESIDUE_RE.test(String(text == null ? '' : text))
+}
+/** F1 结构化转储：以 { / [ 强开幕（后紧跟上引号或嵌套），可能是 JSON 转储。 */
+function looksLikeStructuredDumpPre(trimmed) {
+  // 强开幕：`{"` / `[{` / `["` / `[ 数字` —— 人类散文几乎不会这样开头。
+  const strongOpen = /^\{"|^\[\{|^\[\s*"|^\[\s*\d/.test(trimmed)
+  if (!strongOpen) return false
+  // 已闭合 ⇒ 直接判为转储。
+  if (/[\]}]\s*$/.test(trimmed)) return true
+  // ★ 未闭合：工具回包常被**截断**（真机 title 就是 `{"path":"D:\\…` 断在半路），
+  //   故不能要求收尾符；改为要求「引号键值」特征（`"key":`），散文里不会出现这种配对。
+  return /"[^"]{0,60}"\s*:/.test(trimmed)
+}
+/**
+ * 判定单行是否为信封行。
+ * @param {string} trimmed - 已 trim 的行。
+ * @param {boolean} leadingOnly - true 时只允许 F2（位置约束）；false 时 F1/F2 都允许。
+ */
+function isEnvelopeLinePre(trimmed, leadingOnly, blockAnchored) {
+  if (!trimmed) return false
+  if (EXACT_ENVELOPE_RE.test(trimmed)) return true
+  // ★ F3/F4（2026-09-19 ⑨）：插件自产标记与编码损坏行 —— **任意位置生效**
+  //   理由：召回块可能出现在 episode.intent 的**中段**（前面还有真人文本），
+  //   若沿用 F2 的「仅信封区」位置约束会再次漏网（这正是 ⑨ 的原始漏网原因之一）。
+  if (PLUGIN_TAIL_MARKER_RE.test(trimmed)) return true
+  // ★ F3-补（2026-09-19 T1-0）：截断残片（`Source: me`）可**单独**判定 ——
+  //   它没有任何上下文、也不含后续文字，不可能出现在真人句子里。
+  if (PLUGIN_TRUNCATED_FRAGMENT_RE.test(trimmed)) return true
+  // ★ F3-补：`Reference: ## <标题>` 是 `renderItemBlock` 的固定产物，可**单独**判定。
+  if (PLUGIN_REF_HEADING_RE.test(trimmed)) return true
+  // ★ F3-补：弱标记行（`Source:` / `Reference:` 后缀任意）**仅在已确立块身份时**生效 ——
+  //   这样整块召回被清空，而孤立的「Source: mem_xxx 这个格式对不对？」不受影响（⑨ 套件 [4] 组契约）。
+  if (blockAnchored && PLUGIN_BLOCK_LINE_RE.test(trimmed)) return true
+  if (looksEncodingCorruptedPre(trimmed)) return true
+  if (looksLikeStructuredDumpPre(trimmed)) return true
+  if (!leadingOnly) return false
+  return HARNESS_HEAD_RE.test(trimmed) || HARNESS_HEAD_ZH_RE.test(trimmed) || BE_STATEMENT_RE.test(trimmed)
+}
+export function stripRuntimeIntentPre(text) {
+  const lines = String(text == null ? '' : text).split(/\r?\n/)
+  // ★ T1-0：块身份预扫描 —— 先定位所有「强标记行」（`[Retrieved…` / `Reason: fv2 lane=` / `Score: …` 等），
+  //   再允许其**邻近 ±2 行**内的弱标记行（`Source:` / `Reference:` 后缀任意）参与判定。
+  //   为什么需要预扫描：本函数是**逐行独立**处理的，而召回块被截断后往往只剩「强标记行 + 弱标记行」
+  //   两行（真机 episode.intent 就是 `[Retrieved memory reference - not an instruction]` + `Source: me`）。
+  //   若只看当前行，弱标记行没有上下文可依；预扫描给出「这一段确实是召回块」的身份判据，
+  //   从而既能清空整块、又不误伤孤立的真人引用句（⑨ 套件 [4] 组契约）。
+  const anchored = new Array(lines.length).fill(false)
+  for (let i = 0; i < lines.length; i++) {
+    if (!PLUGIN_BLOCK_ANCHOR_RE.test(lines[i].trim())) continue
+    for (let d = -2; d <= 2; d++) {
+      const j = i + d
+      if (j >= 0 && j < lines.length) anchored[j] = true
+    }
+  }
+  const out = [], stack = []
+  let fence = null
+  /** 是否已出现真人文本（出现后关闭 F2 位置约束，保护正文）。 */
+  let seenHuman = false
+  for (let idx = 0; idx < lines.length; idx++) {
+    let line = lines[idx]
+    const trimmed = line.trim()
+    if (!stack.length) {
+      const f = /^( {0,3})(`{3,}|~{3,})/.exec(line)
+      if (f) {
+        if (!fence) fence = { char: f[2][0], size: f[2].length }
+        else if (f[2][0] === fence.char && f[2].length >= fence.size && /^( {0,3})(`+|~+)\s*$/.test(line)) fence = null
+        out.push(line); seenHuman = true; continue
+      }
+      if (fence || /^\s*>/.test(line) || /^ {4}/.test(line)) { out.push(line); seenHuman = true; continue }
+      // ★ 结构判据：F1 任意位置生效；F2 仅在「尚未出现真人文本」的信封区内生效。
+      if (isEnvelopeLinePre(trimmed, !seenHuman, anchored[idx])) continue
+    }
+    // Consume one or more envelopes at the beginning of an unquoted line.
+    // Closing tags can end a prefix split across messages; trailing human text is retained.
+    for (;;) {
+      if (stack.length) {
+        const token = /<(\/?)(memory_system|system-reminder|long_term_memory)>/.exec(line)
+        if (!token) { line = ''; break }
+        line = line.slice(token.index + token[0].length)
+        if (!token[1]) stack.push(token[2])
+        else if (stack[stack.length - 1] === token[2]) stack.pop()
+        continue
+      }
+      const open = /^\s*<(memory_system|system-reminder|long_term_memory)>/.exec(line)
+      if (open && tags.has(open[1])) { stack.push(open[1]); line = line.slice(open[0].length); continue }
+      const close = /^\s*<\/(memory_system|system-reminder|long_term_memory)>/.exec(line)
+      if (close) { line = line.slice(close[0].length); continue }
+      break
+    }
+    if (line.trim()) { out.push(line); seenHuman = true }
+    else if (!stack.length && !trimmed) out.push('')
+  }
+  return out.join('\n')
+}
+/** 导出判据本身，供套件直接断言（避免只能通过整串行为间接验证）。 */
+export const RUNTIME_ENVELOPE_V1 = Object.freeze({
+  EXACT_ENVELOPE_RE,
+  HARNESS_HEAD_RE,
+  HARNESS_HEAD_ZH_RE,
+  PLUGIN_TAIL_MARKER_RE,
+  RUNTIME_RESIDUE_RE,
+  looksEncodingCorruptedPre,
+  looksRuntimeResiduePre,
+  isEnvelopeLinePre: (line) => isEnvelopeLinePre(String(line == null ? '' : line).trim(), true),
+})

package/lib/l0-extract.js CHANGED Viewed

@@ -43,6 +43,49 @@ const SENTENCE_SPLIT_RE = /[。；;!！?？\n]/
 /** 主题块标题后缀：`（12:02）` 或 `(12:02)`。 */
 const HEADING_SUFFIX_RE = /\s*[（(]\s*\d{1,2}:\d{2}\s*[)）]\s*$/
+/**
+ * ★M2.5a（2026-09-18）：**退化标题判据**。
+ *
+ * 规则① 原先假设「有标题 ⇒ 标题即摘要」，该假设**只对日志成立**：
+ *   - 日志 `## 主题（12:02）` → 去掉时间后缀 = 真摘要 ✅
+ *   - **项目/用户级笔记 `## 2026-09-17`（纯日期）→ 去后缀无效 ⇒ L0 = 一个日期** ❌
+ *
+ * 实测（本机真数据，`artifacts/_probe-l0-quality.mjs`）：
+ *   project-notes 16/16 废（100%）、user-notes 46/50 废（92%）、
+ *   log 449 条 0 废、reflection 21 条 0 废。
+ * ⇒ 笔记层（**结论层**）在语义臂里向量彼此几乎相同 ⇒ **几乎不可检索**。
+ *
+ * 判据：标题若「不携带可检索语义」（纯日期/纯时间/纯符号数字/序号/短代号）
+ * ⇒ **不采信，继续下探到规则②**（首个 `- ` 条目首句——那才是笔记的真实内容）。
+ *
+ * 边界：只拦**明显退化**的形态，绝不拦正常标题（宁可漏判，不可误伤）。
+ */
+const DEGENERATE_HEADING_RES = Object.freeze([
+  /^\d{4}[-/.]\d{1,2}[-/.]\d{1,2}$/,          // 2026-09-17 / 2026/9/17
+  /^\d{4}年\d{1,2}月(\d{1,2}日)?$/,            // 2026年9月17日
+  /^\d{1,2}[-/.]\d{1,2}[-/.]\d{2,4}$/,         // 09-17 / 9.17.2026
+  /^\d{1,2}:\d{2}(:\d{2})?$/,                  // 12:02
+  /^[\d\s\-/.·、_]+$/,                          // 纯数字/符号
+  /^第?\s*\d+\s*(章|节|部分|阶段|步|次|条|天|周|月|年)?$/, // 第3节 / 3
+  /^[A-Za-z]{0,3}\d+(\.\d+)*$/,                // v1 / P3 / v1.2.3
+])
+/** 标题是否退化（不携带可检索语义）。 */
+function isDegenerateHeading(title) {
+  const t = clean(title)
+  if (!t) return true
+  // ★ 只按**形态**判，不按长度判。
+  // 教训（2026-09-18，被既有套件抓出）：曾加 `t.length < 4` 作为"过短即退化"的判据，
+  // 结果误伤 `主题甲`（3 个 CJK 字符，是合法标题）⇒ 标题被拒 ⇒ 落到规则② ⇒
+  // 把正文里的隐私标记当成了 L0（`smoke-test-l0-index.mjs` 的"索引不得含原文"断言真红）。
+  // 中文标题短而有效是常态，**长度不是质量信号**。
+  // 纪律：宁可漏判（退化标题照旧被当摘要），不可误伤（合法标题被拒而拉入正文）。
+  return DEGENERATE_HEADING_RES.some((re) => re.test(t))
+}
+/** 行级标题正则（与规则① 同一口径，供剥标题用）。 */
+const HEADING_LINE_RE = /^\s{0,3}#{1,6}\s+(.+?)\s*$/
 export const L0_DEFAULTS = Object.freeze({
   maxChars: 160,
   minChars: 15,
@@ -112,6 +155,74 @@ export function classifyLayerPre(source) {
   return null
 }
+/** R4-B（2026-09-18）：分层**呈现**用的层序（最高优先在前）。
+ *
+ * 与 `recall-fusion.js:FUSION_LAYER_ORDER_V1` / `tier-layer-inject.js:TIER_LAYER_ORDER_V1`
+ * **同序但独立声明** —— 本仓既有约定：跨模块不共享同一常量对象，避免一处改动静默改变另一处语义；
+ * 三者相等由断言锁定（见 smoke-test-r4-recall-layers-pre.mjs）。 */
+export const L0_LAYER_DISPLAY_ORDER_V1 = Object.freeze(['project', 'whiteboard', 'user', 'reflection', 'log'])
+/** R4-B：层 → 呈现标题。措辞刻意让「结论」与「流水」一眼可分 —— 这正是检索区分度问题的靶心：
+ *  语义臂内部不分层（`index.js` 纯分数 sort）时，模型看到的 MEMORY.md（结论）与 2026-09-xx.md（流水）
+ *  在视觉上完全同级，含金量被数量淹没。 */
+export const L0_LAYER_LABELS_V1 = Object.freeze({
+  project: '结论层 · 项目笔记',
+  user: '结论层 · 用户级记忆',
+  whiteboard: '结论层 · 白板/账本',
+  reflection: '反思层 · 每日反思',
+  log: '流水层 · 每日日志',
+})
+/** 判不出层时的兜底标题：**不猜层**，如实说"未分层"，且固定排在最后（避免给出错误的层次暗示）。 */
+export const L0_LAYER_UNKNOWN_LABEL_V1 = '未分层'
+/**
+ * R4-B（2026-09-18）：把检索命中**按层分组**（**只改呈现，不改排序**）。
+ *
+ * 硬契约（与本仓"回滚必须逐字节相同"纪律对齐）：
+ *   ① **不增删条目**：输出各组条目总数 = 入参长度，且**层内保持入参原相对顺序**
+ *      ⇒ 调用方无需改排序；`#finalRank` 标签仍在行内，排序信息可完全还原；
+ *   ② 组顺序 = `L0_LAYER_DISPLAY_ORDER_V1`；判不出层的固定归**末组**；
+ *   ③ 空入参 / 非数组 / 取层函数抛错 → **永不抛**（fail-soft：呈现层失败绝不打断检索）。
+ *
+ * 调用方职责：**只有一组时不打标题** ⇒ 单一层（如纯日志命中）的输出与旧版逐字节相同。
+ *
+ * @param {Array} items 命中条目
+ * @param {(item:any)=>string} layerOf 取层函数（返回值经 classifyLayerPre 归一）
+ * @returns {Array<{layer:string,label:string,items:Array}>}
+ */
+export function groupL0ByLayerPre(items, layerOf) {
+  const groups = []
+  try {
+    if (!Array.isArray(items) || !items.length) return groups
+    const fn = typeof layerOf === 'function' ? layerOf : () => ''
+    /** @type {Map<string, Array>} 层 → 条目（插入序即入参相对序） */
+    const byLayer = new Map()
+    for (const it of items) {
+      let layer = null
+      try { layer = classifyLayerPre(fn(it)) } catch (_) { layer = null }
+      const key = layer || ''
+      if (!byLayer.has(key)) byLayer.set(key, [])
+      byLayer.get(key).push(it)
+    }
+    // 已知层按契约层序；未知层紧随其后，保持首次出现序。
+    // ★注：`classifyLayerPre` 的返回值域是**闭合词表**（L0_LAYERS 或 null），故下面
+    //   `l && ...` 分支**当前不可达** —— 保留它是有意的前向兼容：将来 L0_LAYERS 扩容时，
+    //   旧版调用方不会把新层误并入"未分层"，而是照实单独成组。
+    //   （变异演示已证实：改这一段不会让任何断言变红 —— 它确实不参与当下语义。）
+    const ordered = L0_LAYER_DISPLAY_ORDER_V1.filter((l) => byLayer.has(l))
+    for (const l of byLayer.keys()) if (l && ordered.indexOf(l) === -1) ordered.push(l)
+    for (const l of ordered) {
+      groups.push({ layer: l, label: L0_LAYER_LABELS_V1[l] || l, items: byLayer.get(l) })
+    }
+    // 未分层固定末组（不猜层）—— **不走通用流程**：它不属层词表，也不该排在结论层之前。
+    if (byLayer.has('')) {
+      groups.push({ layer: '', label: L0_LAYER_UNKNOWN_LABEL_V1, items: byLayer.get('') })
+    }
+  } catch (_) { /* fail-soft：分组失败即降级为"无分组"，调用方按单组处理，检索不受影响 */ }
+  return groups
+}
 /**
  * 三层契约 I5 的**检索侧过滤谓词**：只有 `status === 'current'` 的记录可进入检索与注入。
  *
@@ -128,6 +239,77 @@ export function isCurrentPre(record) {
   return st === 'current'
 }
+/**
+ * ★R4-A（2026-09-19 定稿）：**检索侧**准入谓词 —— I5 的**收窄**版。
+ *
+ * ── 变更依据（用户两次修正后定稿）──────────────────────────────────
+ * 原 I5（`THREE-LAYER-CONTRACT.md:183`）：「非 `current` 的条目在**检索结果与注入内容两处**都被过滤」。
+ *
+ * ① 用户第一次修正：「**返回但标记是正确的**」⇒ 检索侧改为放行 + 标记。
+ * ② 用户第二次修正（**推翻 agent 的"retracted 继续硬挡"方案**）：
+ *    「这个 retracted **不是过滤掉**……**并不是挡，我感觉是备注**。
+ *      因为比如说你之前踩过 3 次的那个坑，如果你不记住这个教训的话，你还会再踩。」
+ *
+ * ⇒ **三态一律返回、一律标记**。agent 原方案按「检索视角」分（过时的别干扰判断）；
+ *   用户按「**学习视角**」分（**做错的事恰恰最该被记住**）。
+ *   对记忆系统而言后者才是目的：`retracted` 不是垃圾数据，它是**一条教训**——
+ *   把它藏起来 = **系统性遗忘自己的错误**，正是「还会再踩」的成因。
+ *
+ * ⇒ **本谓词不再过滤任何已知 status**，只对**未知值 fail-closed**
+ *   （防将来新增枚举时静默放行 —— 枚举类常量必须配断言兜底，本仓纪律）。
+ *
+ * ── 与注入侧的分工（本谓词只用于检索侧）─────────────────────────
+ * 注入侧仍用 `isCurrentPre`：注入是**常驻目录**（B0 仅 800 token），
+ * 拿常驻预算装过时条目会挤掉现行结论；检索是**按需**的，装一条带警告的过时结论划算。
+ * ⇒ **两处判据不同是有意为之**，不是漏改（`tier-layer-inject.js` 继续 import `isCurrentPre`）。
+ *
+ * @param {{status?:string}|null|undefined} record 记录（或任何带 status 的对象）
+ * @returns {boolean} 是否可进入检索结果
+ */
+export function isRetrievablePre(record) {
+  if (!record || typeof record !== 'object') return true
+  const st = record.status
+  if (st === undefined || st === null || st === '') return true
+  // 已知三态一律放行（含 retracted —— 它是教训，不是垃圾）；未知值 fail-closed。
+  return L0_STATUSES.includes(st)
+}
+/** 检索侧标记语的取值域（枚举类常量须配断言兜底 —— 本仓纪律）。 */
+export const L0_SUPERSEDED_MARK_V1 = '⚠已作废'
+export const L0_RETRACTED_MARK_V1 = '⚠已撤回'
+/**
+ * 为「返回但标记」生成**呈现后缀**（R4-A 的可见面）。
+ *
+ * 契约（**逐字节向后兼容**是硬约束）：
+ *   `current` / 缺 status / 未知 / 非对象 ⇒ 空串（旧行为零变化）
+ *   `superseded` ⇒ ` ⚠已作废（已被 mem_<32hex> 取代）`
+ *   `retracted`  ⇒ ` ⚠已撤回（原因：<reason>；更正见 mem_<32hex>）`
+ *
+ * `reason` 才是「教训」的正文，比 status 本身有价值（用户第二次修正的要点）。
+ * id 只认 `/^mem_[0-9a-f]{32}$/`，不合法一律丢弃 —— 防止把任意文本拼进检索呈现。
+ *
+ * @param {{status?:string, supersededBy?:string, reason?:string}} record
+ * @returns {string} 追加到条目末尾的后缀（含前导空格；无需标记时为空串）
+ */
+export function supersededMarkPre(record) {
+  try {
+    if (!record || typeof record !== 'object') return ''
+    const idOf = (v) => (/^mem_[0-9a-f]{32}$/.test(String(v || '').trim()) ? String(v).trim() : '')
+    if (record.status === 'superseded') {
+      const safe = idOf(record.supersededBy)
+      return ' ' + L0_SUPERSEDED_MARK_V1 + (safe ? '（已被 ' + safe + ' 取代）' : '（已被更新结论取代）')
+    }
+    if (record.status === 'retracted') {
+      const safe = idOf(record.supersededBy)
+      const reason = record.reason ? String(record.reason).replace(/[\r\n]+/g, ' ').trim().slice(0, 80) : ''
+      const tail = (reason ? '原因：' + reason + '；' : '') + (safe ? '更正见 ' + safe : '已被撤回')
+      return ' ' + L0_RETRACTED_MARK_V1 + '（' + tail + '）'
+    }
+    return ''
+  } catch (_) { return '' }   // fail-soft：标记失败绝不影响检索
+}
 /**
  * 按锚点切分记忆条目。
  *
@@ -175,13 +357,15 @@ export function extractL0Pre(body, opts = {}) {
   const lines = text.split(/\r?\n/)
-  // ① 主题块标题
+  // ① 主题块标题（★M2.5a：加质量门 —— 退化标题不采信，继续下探）
   for (const line of lines) {
-    const h = /^\s{0,3}#{1,6}\s+(.+?)\s*$/.exec(line)
-    if (h) {
-      const title = clean(h[1]).replace(HEADING_SUFFIX_RE, '')
-      if (title) return { l0: cut(title, maxChars), source: 'heading' }
-    }
+    const h = HEADING_LINE_RE.exec(line)
+    if (!h) continue
+    const title = clean(h[1]).replace(HEADING_SUFFIX_RE, '')
+    if (!title) continue
+    // 退化标题（纯日期/纯时间/序号/短代号）不携带可检索语义 ⇒ 跳过，让规则② 取真实内容。
+    if (isDegenerateHeading(title)) continue
+    return { l0: cut(title, maxChars), source: 'heading' }
   }
   // ② 首个 `- ` 条目：先取首句，过短再并接（并接时剥列表标记与时间戳）
@@ -195,8 +379,11 @@ export function extractL0Pre(body, opts = {}) {
     return { l0: cut(s, maxChars), source: 'firstSentence' }
   }
-  // ③ 兜底：正文截断
-  const flat = clean(text.replace(/\s+/g, ' '))
+  // ③ 兜底：正文截断（★M2.5a：先剥标题行 —— 否则退化标题会被压进 L0）
+  // 场景：条目既无标题（或标题已退化被跳过）又无 `- ` 列表项时落到此处；
+  // 直接压平会把 `## 2026-09-09` 变成 L0 开头（实测 user-notes 修后仍见该形态）。
+  const bodyLines = lines.filter((l) => !HEADING_LINE_RE.test(l))
+  const flat = clean((bodyLines.length ? bodyLines : lines).join('\n').replace(/\s+/g, ' '))
   return { l0: cut(flat, maxChars), source: 'truncate' }
 }
@@ -207,23 +394,45 @@ export function extractL0Pre(body, opts = {}) {
  * 老调用方读 `id / l0 / source / chars / bodyChars` 完全不受影响，签名与调用方式不变。
  * 层归属：`opts.layer`（层名 / 路径 / 键名，经 classifyLayerPre）→ `opts.path` → `L0_DEFAULT_LAYER`。
  *
+ * ★R4-A（2026-09-18）：新增**可选** `opts.statusOf(id)` 注入解析器 —— 让本模块保持
+ *   **零 IO 纯函数**（存储格式属写入侧 G3 的决定，本层只透传，不猜存储）。
+ *   未注入时行为与从前**逐字节相同**（`status` 恒 `'current'`）⇒ 向后兼容。
+ *
  * @param {string} text 文件内容
- * @param {{maxChars?:number, minChars?:number, layer?:string, path?:string}} [opts]
- * @returns {Array<{id:string, l0:string, source:string, chars:number, bodyChars:number, layer:string, status:string}>}
+ * @param {{maxChars?:number, minChars?:number, layer?:string, path?:string,
+ *          statusOf?:(id:string)=>({status?:string, supersededBy?:string}|null|undefined)}} [opts]
+ * @returns {Array<{id:string, l0:string, source:string, chars:number, bodyChars:number, layer:string, status:string, supersededBy?:string}>}
  */
 export function buildL0IndexPre(text, opts = {}) {
   const { items } = parseMemoryItemsPre(text)
   const layer = resolveLayerPre(opts)
+  const statusOf = opts && typeof opts.statusOf === 'function' ? opts.statusOf : null
   const out = items.map((it) => {
     const r = extractL0Pre(it.body, opts)
-    // TODO(C1 写入侧，未实现)：status 恒为 current。superseded（被新记录经 supersedes 替代改正）
-    //   与 retracted（人工判定作废）需要**写入侧先落盘状态**（fact-store 的 supersedes 边 / 审计视图标记），
-    //   本层不做存储、只负责透传；存储与双层过滤（契约 I5）在 C2 接线 + 写入侧一起做。
-    const status = 'current'
-    return {
+    // C1 写入侧（G3）落盘状态后，由调用方经 `statusOf` 注入；本层只透传。
+    // fail-closed 语义在**消费侧**（isRetrievablePre 未知值挡下），此处只做形态净化。
+    let status = 'current'
+    let supersededBy
+    let reason
+    if (statusOf) {
+      try {
+        const st = statusOf(it.id)
+        if (st && typeof st === 'object') {
+          if (typeof st.status === 'string' && L0_STATUSES.includes(st.status)) status = st.status
+          if (typeof st.supersededBy === 'string' && st.supersededBy) supersededBy = st.supersededBy
+          // R4-A：撤回原因 —— 这才是「教训」的正文，比 status 本身有价值。
+          if (typeof st.reason === 'string' && st.reason) reason = st.reason
+        }
+      } catch (_) { /* fail-soft：状态解析失败 ⇒ 按 current 处理，绝不影响索引构建 */ }
+    }
+    const rec = {
       id: it.id, l0: r.l0, source: r.source, chars: r.l0.length, bodyChars: it.body.length,
       layer, status,
     }
+    // 只在真的有值时附字段 —— 保证「无状态时」输出与旧版逐字节相同。
+    if (supersededBy) rec.supersededBy = supersededBy
+    if (reason) rec.reason = reason
+    return rec
   })
   out.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
   return out
@@ -249,7 +458,13 @@ function cut(s, n) {
 /** 首句过短时，并接后续句子直到 minChars 或 maxChars。每句先剥列表标记与时间戳前缀。 */
 function growToMin(first, full, minChars, maxChars) {
   if (first.length >= minChars) return first
-  const flat = clean(full.replace(/\s+/g, ' '))
+  // ★ issue #71 修复（2026-09-19）：**保留换行结构**。
+  //   旧实现先 `full.replace(/\s+/g, ' ')` 把换行压成空格，**再用含 `\n` 的 SENTENCE_SPLIT_RE 切分**
+  //   ⇒ `\n` 分支恒不命中（死代码），整段多行正文被当成**一个 part**；
+  //   而剥前缀的 `/^\s*[-*+]\s+/` 与 `LEAD_TIME_RE` 都是 `^` 锚定，只剥得掉该 part 的**首个**标记
+  //   ⇒ 第 2 行起的 `- HH:MM` 原样进入 L0（嵌入/检索输入）。
+  //   现改为：只把「行内连续空白」压成单空格，**行界 `\n` 保留** ⇒ 逐行切分、逐 part 剥前缀。
+  const flat = clean(full.replace(/[^\S\r\n]+/g, ' ').replace(/\r\n?/g, '\n'))
   if (!flat || flat.length <= first.length) return first
   const parts = flat.split(SENTENCE_SPLIT_RE)
     .map((x) => clean(String(x).replace(/^\s*[-*+]\s+/, '').replace(LEAD_TIME_RE, '')))

package/lib/m4-corpus.js CHANGED Viewed

@@ -94,11 +94,17 @@ export function loadCorpusSnapshot(catalog, io = {}, opts = {}) {
     if (buf.length > INDEX_MAX_FILE_BYTES) { dropped.push({ stage: 'corpus', reason: 'oversized', sourceRef: source.sourceRef }); continue }
     const fileDigest = sha256Hex(buf)
     if (fileDigest !== sc.fileDigest) { dropped.push({ stage: 'corpus', reason: 'stale-source', sourceRef: source.sourceRef }); continue }
+    // ★ issue #66 修复（2026-09-19）：**byteStart/byteEnd 是相对「剥掉 BOM 之后」的坐标系**
+    //   （契约见 `memory-anchor.js` 的 `parseAnchors` 与其 C18 断言；`fileDigest` 则按含 BOM 的整 buffer 算）。
+    //   旧实现直接 `buf.subarray(...)` 用在**含 BOM 的原 buffer** 上 ⇒ BOM 文件整体偏 3 字节
+    //   ⇒ `recordDigest` 恒不等 ⇒ 该文件**全部记录被判 record-stale 丢弃**，从语料/召回静默消失。
+    //   修法：消费侧对齐——有 BOM 时先剥掉再切片（无 BOM 时 body === buf，零行为变化）。
+    const body = (buf.length >= 3 && buf[0] === 0xef && buf[1] === 0xbb && buf[2] === 0xbf) ? buf.subarray(3) : buf
     for (const r of (sc.records || [])) {
-      if (!Number.isInteger(r.byteStart) || !Number.isInteger(r.byteEnd) || r.byteStart < 0 || r.byteEnd > buf.length) {
+      if (!Number.isInteger(r.byteStart) || !Number.isInteger(r.byteEnd) || r.byteStart < 0 || r.byteEnd > body.length) {
         dropped.push({ stage: 'corpus', reason: 'record-stale', memoryId: r.memoryId, sourceRef: source.sourceRef }); continue
       }
-      if (sha256Hex(buf.subarray(r.byteStart, r.byteEnd)) !== r.recordDigest) {
+      if (sha256Hex(body.subarray(r.byteStart, r.byteEnd)) !== r.recordDigest) {
         dropped.push({ stage: 'corpus', reason: 'record-stale', memoryId: r.memoryId, sourceRef: source.sourceRef }); continue
       }
       records.push({

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

@@ -98,7 +98,14 @@ export function createIndexSyncHostPre(opts = {}) {
       drop('generation-reset', 0, ctxKey)
     }
     // epoch 变化(worker 重启) → 缓存失效,必须重同步
-    if (cached && epoch && cached.epoch !== epoch) {
+    // ★ issue #69 修复（2026-09-19）：判据补上「**cached.epoch 为空 ⇒ 一律视为无效**」。
+    //   旧写法 `if (cached && epoch && cached.epoch !== epoch)` 里的 **`epoch &&` 前置**是缺陷所在：
+    //   当 `currentEpoch()` 返回 null（**client 未启动 / 已 exit 但 stdio 未排空**）时，该分支**永不成立**
+    //   ⇒ 一条 `cached.epoch === null` 的旧缓存（冷启动时采样于 lazy spawn 之前，见 `:90`）会被一直保留
+    //   ⇒ 对刚 spawn 出来的空索引 worker 误判 `ready=true`，该段 `context_push` 拿到零候选零激活，
+    //   且 `context-host` 的 `indexNotReady` 也不点亮（readyRes.ready 为 true）⇒ **连降级留痕都没有**。
+    //   保留旧语义的另一半（epoch 非空时要求严格相等）——worker 重启换 epoch 仍会正常失效重同步。
+    if (cached && (!cached.epoch || (epoch && cached.epoch !== epoch))) {
       readyCache.delete(k)
       stats.epochReset++
       drop('epoch-reset', 0, ctxKey)