@a9i5k4/dsh-auto-memory 3.0.0 → 3.0.1

package/lib/procedure-store.js

@@ -261,8 +261,24 @@ export function createProcedureStorePre(opts = {}) {
   /**
    * 晋升判定(M-04 元代码 promote 逐行)。
    * 返回 { decision: 'promote'|'keep'|'ask', procedure, reasonCodes }
+   *
+   * ★ T4（2026-09-19 用户拍板「让大模型来介入」）：新增第三个参数 `opts`。
+   *   `opts.authorizedBy`（如 'model'）= **模型显式授权**，用于跳过两条**统计证据门**
+   *   （`minSessionDiversity` / `minSuccessCount`）。
+   *
+   *   为什么需要它：这两条门是给**机械生成**的观察行用的防污染护栏 —— 它们靠"反复出现"累积证据。
+   *   但机械路径产出的条目 13/14 是空壳（`actions=['user','user','user']` 切出来的），
+   *   而**模型主动写出的技能**（带真 steps + successCriteria）**天生没有历史证据**，
+   *   若不放行则永远卡在 `diversity-below-3` ⇒ 模型通路等于白建。
+   *
+   *   **仍然保留的护栏（授权也不放行）**：
+   *     · `deprecated` 短路 —— 已弃用的不得复活；
+   *     · `isObservationOnlyPre` 短路 —— 结构上不该晋升的行，授权也拦；
+   *     · **`no-success-criteria` 必须有**（在下方）—— 没写验收标准的不算技能；
+   *     · `correction-rate` / `has-correction` —— 有纠正记录说明这流程是错的。
+   *   并**留痕**：`p.authorizedBy` + reasonCodes 追加 `model-authorized`，供审计与前端展示。
    */
-  function promote(procedureId, extraEvidence = {}) {
+  function promote(procedureId, extraEvidence = {}, opts = {}) {
     if (disposed) return { ok: false, reason: 'disposed' }
     const p = procedures.find((x) => x.procedureId === procedureId)
     if (!p) return { ok: false, reason: 'not-found' }
@@ -270,15 +286,21 @@ export function createProcedureStorePre(opts = {}) {
     // issue #30:纯 episode 观察行没有 successCriteria,本来就无法晋升;
     // 显式短路并给出 `observation-only` 原因码,而不是让它落到下面报 `no-success-criteria`
     // (后者会让使用者误以为"缺判据、补上就能晋升",其实是这行**结构上**不该晋升)。
+    // ★ T4:此短路**不受授权影响** —— 结构上不该晋升的行,模型授权也不放行。
     if (isObservationOnlyPre(p)) return { ok: true, decision: 'keep', procedure: p, reasonCodes: ['observation-only'] }
 
     const ev = p.evidence
     const reason = []
+    const authorizedBy = opts && opts.authorizedBy ? String(opts.authorizedBy) : ''
+    if (authorizedBy) reason.push('model-authorized')
     // 跨会话多样性
     const diversity = extraEvidence.distinctSessions != null ? extraEvidence.distinctSessions : ev.sessions
     const successCount = extraEvidence.successCount != null ? extraEvidence.successCount : ev.success
-    if (diversity < gates.minSessionDiversity) { reason.push('diversity-below-' + gates.minSessionDiversity); return { ok: true, decision: 'keep', procedure: p, reasonCodes: reason } }
-    if (successCount < gates.minSuccessCount) { reason.push('success-below-' + gates.minSuccessCount); return { ok: true, decision: 'keep', procedure: p, reasonCodes: reason } }
+    // ★ T4:两条**统计证据门**在模型授权下跳过(见上方函数注释);未授权时行为逐字节不变。
+    if (!authorizedBy) {
+      if (diversity < gates.minSessionDiversity) { reason.push('diversity-below-' + gates.minSessionDiversity); return { ok: true, decision: 'keep', procedure: p, reasonCodes: reason } }
+      if (successCount < gates.minSuccessCount) { reason.push('success-below-' + gates.minSuccessCount); return { ok: true, decision: 'keep', procedure: p, reasonCodes: reason } }
+    }
     // correction 率
     const total = ev.seen + ev.read + ev.cite + ev.reuse + ev.success + ev.correction
     const corrRate = total > 0 ? ev.correction / total : 0
@@ -302,11 +324,68 @@ export function createProcedureStorePre(opts = {}) {
     // 晋升
     p.stage = 'validated'
     p.updatedAt = nowFn()
+    // ★ T4:授权晋升留痕 —— 前端与审计面必须能看出「这条是模型授权跳门进来的」,
+    //   否则日后无法区分「统计证据充分」与「模型判断值得」两种来源。
+    if (authorizedBy) p.authorizedBy = authorizedBy
     stats.validated++
     void persist()
     return { ok: true, decision: 'promote', procedure: p, reasonCodes: reason }
   }
 
+  /**
+   * ★R2（2026-09-20 用户要求「晋升原因必须看得见」）：**纯只读**晋升判定投影。
+   *
+   * 与 `promote()` 的关系：**逐行复制其门限判定，但不改任何状态**。
+   * 为什么不能直接调 `promote()`：它含真实副作用
+   * （`stats.approvalAsked++` / `p.stage='validated'` / `stats.validated++` / `persist()` 写盘），
+   * 在 `overview()` 这类只读轮询路径里调用会**污染统计并把候选悄悄提升**。
+   * ⇒ 只读面必须走本函数（用户 2026-09-18 冻结纪律）。
+   *
+   * ⚠️ 维护约定：改 `promote()` 的门限时**必须同步改这里**，否则前端会展示过时的判据。
+   * 两者的一致性由测试 `smoke-test-r2-promotion-pre.mjs` 用变异兜底。
+   *
+   * @returns {{ok:boolean, decision?:string, reasonCodes?:string[], detail?:object}}
+   */
+  function evaluatePromotion(procedureId) {
+    const p = procedures.find((x) => x.procedureId === procedureId)
+    if (!p) return { ok: false, reason: 'not-found' }
+    if (p.stage === 'deprecated') return { ok: true, decision: 'keep', reasonCodes: ['deprecated'] }
+    if (isObservationOnlyPre(p)) return { ok: true, decision: 'keep', reasonCodes: ['observation-only'] }
+    const ev = p.evidence || { seen: 0, read: 0, cite: 0, reuse: 0, success: 0, correction: 0, sessions: 0 }
+    const reason = []
+    const diversity = Number(ev.sessions) || 0
+    const successCount = Number(ev.success) || 0
+    const total = (Number(ev.seen) || 0) + (Number(ev.read) || 0) + (Number(ev.cite) || 0)
+      + (Number(ev.reuse) || 0) + successCount + (Number(ev.correction) || 0)
+    const corrRate = total > 0 ? (Number(ev.correction) || 0) / total : 0
+    // ⚠️ 顺序必须与 promote() **完全一致**（先返回的那个才决定前端文案）
+    if (diversity < gates.minSessionDiversity) {
+      reason.push('diversity-below-' + gates.minSessionDiversity)
+      return { ok: true, decision: 'keep', reasonCodes: reason, detail: { diversity, need: gates.minSessionDiversity } }
+    }
+    if (successCount < gates.minSuccessCount) {
+      reason.push('success-below-' + gates.minSuccessCount)
+      return { ok: true, decision: 'keep', reasonCodes: reason, detail: { successCount, need: gates.minSuccessCount } }
+    }
+    if (corrRate > gates.maxCorrectionRate) {
+      reason.push('correction-rate-' + corrRate.toFixed(2))
+      return { ok: true, decision: 'keep', reasonCodes: reason, detail: { corrRate, cap: gates.maxCorrectionRate } }
+    }
+    if (gates.maxContradictions === 0 && (Number(ev.correction) || 0) > 0) {
+      reason.push('has-correction')
+      return { ok: true, decision: 'keep', reasonCodes: reason, detail: { corrections: Number(ev.correction) || 0 } }
+    }
+    if (!p.successCriteria || !p.successCriteria.length) {
+      reason.push('no-success-criteria')
+      return { ok: true, decision: 'keep', reasonCodes: reason }
+    }
+    if (p.requiresApproval && !p.approved) {
+      reason.push('high-risk-awaiting-approval')
+      return { ok: true, decision: 'ask', reasonCodes: reason }
+    }
+    return { ok: true, decision: 'promote', reasonCodes: reason, detail: { diversity, successCount } }
+  }
+
   /** 激活: validated → active(可被召回)。 */
   function activate(procedureId) {
     const p = procedures.find((x) => x.procedureId === procedureId)
@@ -413,6 +492,8 @@ export function createProcedureStorePre(opts = {}) {
   }
 
   return {
+    // ★R2：只读判定投影（供 overview() 展示「为什么不能晋升」）
+    evaluatePromotion,
     observe, addEvidence, promote, activate, deprecate,
     touch, setPinned, applyAutomaticTransitions,
     query, activeProcedures, get, renderChecklist,

package/lib/python-sidecar-client.js

@@ -80,9 +80,14 @@ export function createPythonSidecarClientPre(opts = {}) {
     if (disposed) return { ok: false, code: 'disposed' }
     if (child && (child.killed || (child.stdin && child.stdin.destroyed))) {
       // 上一个进程正在收尾(exit 事件未到):按已死处理,允许立即重生
+      // ★ issue #72 修复（2026-09-19）：此处必须**同时清空共享 buffer**。
+      //   旧实现只置 `epoch = null`（等 `:121` 的 exit 事件去清 buffer），但这条分支的前提正是
+      //   **exit 尚未到达** ⇒ 旧 worker 残留在 `buffer` 里的**无换行尾字节**会被新 worker 的首帧
+      //   `concat` 进去 ⇒ 该行 badJson ⇒ 应答被吞、请求白等到超时（默认 5000ms）。
       try { child.kill() } catch (_) {}
       child = null
       epoch = null
+      buffer = Buffer.alloc(0)   // ★ 丢弃旧代残尾,避免污染新 worker 首帧
     }
     if (child) return { ok: true }
     const scriptPath = String(resolveOpt('scriptPath') || defaultWorkerScriptPathPre())
@@ -161,7 +166,16 @@ export function createPythonSidecarClientPre(opts = {}) {
     const v = validateTransportFramePre(obj, { direction: 'in' })
     if (!v.ok) { stats.dropped.badEnvelope++; return }
     const frame = v.frame
-    if (epoch !== null && frame.workerEpoch !== epoch) { stats.dropped.staleEpoch++; return }
+    // ★ issue #72 修复（2026-09-19）：把入站 epoch 门从 **fail-open 改为 fail-closed**，与文件头 :7 的承诺一致。
+    //   旧写法 `if (epoch !== null && frame.workerEpoch !== epoch)`：**`epoch === null` 时整条门失效**，
+    //   任何合法 envelope 的帧都会穿透到 handler。epoch 为 null 的窗口是真实存在的
+    //   （未启动 / `exit` 事件已置 null 但旧 stdio 尚未排空 / restart 后到新 spawn 之间），
+    //   而 `activation_request` 上游 `context-host` **无二次校验**（同 activationId 有 dedup 兜底，
+    //   但**新 activationId 可穿透**）⇒ 幽灵激活。
+    //   新判据：**epoch 为空 ⇒ 一律丢弃**。理由：spawn 时同步赋 epoch（:91 `epoch = 'wk_' + …` 在
+    //   `spawn()` **之前**执行），出站帧也就带上了 epoch；对端 worker 以 `--expect-epoch` 自证身份后才回帧
+    //   ⇒ **正常路径不存在"帧先于 epoch"**，丢弃不会误伤任何合法流量。
+    if (!epoch || frame.workerEpoch !== epoch) { stats.dropped.staleEpoch++; return }
     if (frame.type === 'activation_request') {
       const activation = frame.payload && frame.payload.activation
       const aid = activation && activation.activationId
@@ -208,9 +222,18 @@ export function createPythonSidecarClientPre(opts = {}) {
     lastSentFrame = frame
     if (!child || !child.stdin || child.stdin.destroyed) return false
     const line = Buffer.from(JSON.stringify(frame) + '\n', 'utf8')
+    // ★ issue #75 CC-9 修复（2026-09-19）：**建帧时捕获当时的 child 引用**，flush 时校验身份。
+    //   旧实现：`writeChain.then(...)` 回调里解引用**当时的**模块级 `child` 变量。
+    //   若 writeChain 排队期间发生 respawn（`ensureStarted` 的收尾中重生 / `restart()`），
+    //   回调会读到**新** child，把**旧 epoch 的帧**写进新 worker 的 stdin ⇒ 对端回帧 epoch-mismatch
+    //   ⇒ 被判 `staleEpoch` 丢弃 ⇒ 该请求挂满自身超时（默认 5000ms）。
+    //   现改为闭包捕获 `sentTo`，且 flush 时 `child !== sentTo` 即视为该帧已随旧进程作废。
+    const sentTo = child
+    const sentStdin = child.stdin
     writeChain = writeChain.then(() => new Promise((done) => {
-      if (!child || !child.stdin || child.stdin.destroyed) { done(); return }
-      child.stdin.write(line, () => done())
+      if (child !== sentTo) { done(); return }   // 已换代：本帧作废，不得写入新 worker
+      if (!sentStdin || sentStdin.destroyed) { done(); return }
+      sentStdin.write(line, () => done())
     }))
     writeChain = writeChain.catch(() => {})
     return true
@@ -282,6 +305,9 @@ export function createPythonSidecarClientPre(opts = {}) {
     if (child) { try { child.kill() } catch (_) {} }
     child = null
     epoch = null
+    // ★ issue #72 修复：restart 同样要清 buffer（kill 后 exit 事件可能滞后，
+    //   旧代残尾会污染新 worker 首帧 ⇒ 该行 badJson ⇒ 请求白等到超时）。
+    buffer = Buffer.alloc(0)
     stats.restarts++
     void reason
   }

package/lib/recall-fusion.js

@@ -21,6 +21,19 @@ export const FUSION_RRF_K_V1 = 60
 /** rank 尺度常数:rank/divisor 把秩归到 (0,1] 量级(默认与 k 同值)。 */
 export const FUSION_RRF_DIVISOR_V1 = 60
 
+/**
+ * ★M2.5b：层次优先级序（与注入侧一致）。
+ *
+ * 出处：`tier-layer-inject.js:58 TIER_LAYER_ORDER_V1` —— **必须与之逐字相同**。
+ *
+ * 为什么不直接 import：本模块头注释承诺「**零依赖**、纯函数、零 IO」，
+ *   引入跨模块依赖会破坏该契约（且 tier-layer-inject 自身还有依赖链）。
+ * 为了既不破契约、又不产生「双源漂移」，此处**本地复刻**并由测试**断言两者相等**
+ *   （见 smoke-test-m25b-layer-arm-pre.mjs 的「常量一致性」断言）——
+ *   任何一侧改动而另一侧未同步，测试立刻红。
+ */
+export const FUSION_LAYER_ORDER_V1 = Object.freeze(['project', 'whiteboard', 'user', 'reflection', 'log'])
+
 /** 版本标识。 */
 export const RECALL_FUSION_VERSION = 'rrf_fusion_v1'
 
@@ -45,20 +58,63 @@ export function rankFusionRRFPre(pairs, opts = {}) {
   const list = Array.isArray(pairs) ? pairs.filter((p) => p && typeof p.memoryId === 'string') : []
 
   // 每臂独立排名:非空有限值按分数降序(平局 memoryId 升序)取秩(1 起);缺席者无秩。
-  const rankArm = (key) => {
+  // ★M2.5b：新增 `strMode` —— 层次臂的值是**字符串**，默认的「只收有限数」过滤会把它全部滤掉
+  //   （实测踩坑：layer 臂曾因此静默恒为 0，套件 [3] 抓到）。strMode=true 时接受非空字符串。
+  const rankArm = (key, cmp, strMode) => {
     const entries = []
     for (const p of list) {
       const v = p[key]
-      if (typeof v === 'number' && Number.isFinite(v)) entries.push({ memoryId: p.memoryId, v })
+      if (strMode) {
+        if (typeof v === 'string' && v) entries.push({ memoryId: p.memoryId, v })
+      } else if (typeof v === 'number' && Number.isFinite(v)) {
+        entries.push({ memoryId: p.memoryId, v })
+      }
     }
-    entries.sort((a, b) => (b.v !== a.v ? b.v - a.v : (a.memoryId < b.memoryId ? -1 : a.memoryId > b.memoryId ? 1 : 0)))
+    const tie = (a, b) => (a.memoryId < b.memoryId ? -1 : a.memoryId > b.memoryId ? 1 : 0)
+    entries.sort(cmp || ((a, b) => (b.v !== a.v ? b.v - a.v : tie(a, b))))
     const ranks = new Map()
     entries.forEach((e, i) => ranks.set(e.memoryId, i + 1))
     return ranks
   }
+
+  /**
+   * ★M2.5b：层次臂的**序** = 注入侧的层次优先级序（二者必须一致）。
+   * 出处：`tier-layer-inject.js:58 TIER_LAYER_ORDER_V1`
+   *       = ['project','whiteboard','user','reflection','log']。
+   * 语义：**rank 1 = 最高优先级层**。未列出的层（含新增层）排在已知层之后，按名称升序（确定性）。
+   * 注意：这里只定义**偏好顺序**，不定义权重；权重问题走 rank-space（见下），
+   *       需要调权重时应改分档/序，而不是给分数乘系数（Hindsight #3956）。
+   */
+  const layerRankOf = (name) => {
+    const i = FUSION_LAYER_ORDER_V1.indexOf(name)
+    return i >= 0 ? i : FUSION_LAYER_ORDER_V1.length
+  }
+  const cmpLayer = (a, b) => {
+    const la = layerRankOf(String(a.v))
+    const lb = layerRankOf(String(b.v))
+    if (la !== lb) return la - lb
+    const sa = String(a.v), sb = String(b.v)
+    if (sa !== sb) return sa < sb ? -1 : 1
+    return a.memoryId < b.memoryId ? -1 : a.memoryId > b.memoryId ? 1 : 0
+  }
+
   const denseRanks = rankArm('dense')
   const lexRanks = rankArm('lex')
 
+  // ★M2.5b 层次臂（2026-09-18）：可选第四臂。layer 为层次名（'project'/'user'/'log'/
+  // 'reflection'/'whiteboard'）或缺失。与时间臂同一条**退化安全**纪律：
+  //   所有 pair 均缺 layer **或 layer 全相等** → 不构建 layer 秩，行为与三臂版**逐字节一致**
+  //   （fused 不加 0 项、输出对象不含新字段）。
+  // 为什么需要它（实测不一致，2026-09-18）：Tier-0 **注入**侧有层次优先级
+  //   （tier-layer-inject.js:58 TIER_LAYER_ORDER_V1 = ['project','whiteboard','user','reflection','log']
+  //    + tier0-catalog.js:419-455 的 caps/floors），而 **排序**侧对层次完全无感
+  //   ⇒ 结论层（project）与流水层（log）在融合里**平等竞争**，笔记层常被日志挤掉。
+  // rank-space（Hindsight #3956 禁止 score-space 加权）：层次只贡献**秩**，不乘分。
+  const layers = []
+  for (const p of list) { if (typeof p.layer === 'string' && p.layer) layers.push(p.layer) }
+  const hasLayer = layers.length > 0 && layers.some((v) => v !== layers[0])
+  const layerRanks = hasLayer ? rankArm('layer', cmpLayer, true) : null
+
   // 时间臂(P12 后新增,2026-09-09):可选第三臂。temp 为 1(命中时间范围)/0(未命中)/
   // 缺失(无时间臂或非日期来源)。所有 pair 均缺 temp **或 temp 全相等**(全 0/全 1)→
   // 不构建 temp 秩,行为与两臂版逐字节一致(fused 不加 0 项、输出对象不含新字段)——
@@ -84,16 +140,31 @@ export function rankFusionRRFPre(pairs, opts = {}) {
         rankDense: rd === undefined ? null : rd,
         rankLex: rl === undefined ? null : rl,
       }
-      if (!hasTemp) return base
-      const rt = tempRanks.get(p.memoryId)
-      const rrfTemp = rt === undefined ? 0 : 1 / (k + rt / divisor)
-      return {
-        ...base,
-        fused: rrfDense + rrfLex + rrfTemp,
-        rrfTemp,
-        tempRaw: typeof p.temp === 'number' && Number.isFinite(p.temp) ? p.temp : null,
-        rankTemp: rt === undefined ? null : rt,
+      // 时间臂与层次臂**互不依赖**：各自独立判 has*，可单独生效、可同时生效。
+      let out = base
+      if (hasTemp) {
+        const rt = tempRanks.get(p.memoryId)
+        const rrfTemp = rt === undefined ? 0 : 1 / (k + rt / divisor)
+        out = {
+          ...out,
+          fused: out.fused + rrfTemp,
+          rrfTemp,
+          tempRaw: typeof p.temp === 'number' && Number.isFinite(p.temp) ? p.temp : null,
+          rankTemp: rt === undefined ? null : rt,
+        }
+      }
+      if (hasLayer) {
+        const rlay = layerRanks.get(p.memoryId)
+        const rrfLayer = rlay === undefined ? 0 : 1 / (k + rlay / divisor)
+        out = {
+          ...out,
+          fused: out.fused + rrfLayer,
+          rrfLayer,
+          layerRaw: typeof p.layer === 'string' && p.layer ? p.layer : null,
+          rankLayer: rlay === undefined ? null : rlay,
+        }
       }
+      return out
     })
     .sort((x, y) => (y.fused !== x.fused ? y.fused - x.fused : (x.memoryId < y.memoryId ? -1 : x.memoryId > y.memoryId ? 1 : 0)))
 }

package/lib/rules-edit.js

@@ -0,0 +1,159 @@
+/**
+ * rules-edit.js —— 「用户级硬性约束」的**条目级**解析与增删改（R7 需求）。
+ *
+ * ## 背景（用户 2026-09-20 明确要求「这个功能必须要落在前端」）
+ *
+ * `[规则 — 用户级硬性约束 · 必须遵守]` 这一段是**每轮无条件注入**的硬约束，
+ * 真源 = `~/.dsh/memory/MEMORY.md`（见 `rules-layer.js:12` 的真源纪律）。
+ * 它**不走语义层** —— 即没有检索/打分/淘汰环节 ⇒ **过时条目不会被自动清理**；
+ * 而 AI（`memory_user`）也会往里写错东西。
+ * ⇒ 用户必须能**自己增/删/改**，否则错一条就每轮都被误导。
+ *
+ * ## 与既有渲染层的关系（重要：本模块不改变注入语义）
+ *
+ * `rules-layer.js` 的 `extractRulesLayerPre()` 负责**读**（把 MEMORY.md 解析成规则段），
+ * `renderRulesSectionPre()` 负责**渲染**。本模块只做**编辑定位**：
+ * 给定原文，找出「哪一段是规则段、每条规则在第几行」，以及产出改后的新全文。
+ * 它**不碰**注入、不碰检索、不碰 store。
+ *
+ * ## 条目模型
+ *
+ * 用户级 MEMORY.md 由若干 `## YYYY-MM-DD` 日期段 + `- ` 条目行组成。
+ * `rules-layer.js` 的渲染器只取 `- ` 开头的行（且跳过日期段）。
+ * ⇒ **一条规则 = 一个 `- ` 行**。本模块据此提供：
+ *   - `listRuleItemsPre(text)`      → [{ line, indent, text, source }]
+ *   - `updateRuleItemPre(text, i, next)` / `removeRuleItemPre(text, i)` / `appendRuleItemPre(text, body)`
+ *
+ * `source` 的判定：条目若落在 `## YYYY-MM-DD` 段内 ⇒ 归该日期（多为 AI 写入）；
+ * 落在段外（文件头部）⇒ 记为 `user`（多为用户手写）。这是 R7-3「标注来源」的依据。
+ *
+ * ## 纪律
+ *   - 纯函数：输入文本、输出文本，**不做任何 IO**（IO 由调用方走既有 writeFull 事务）。
+ *   - **删除 = 真删**（见 R7-4）：本层渲染器不认任何状态标记，软删标记会被当正文注入模型。
+ *   - 零运行时依赖。CRLF、无 BOM。
+ */
+
+/** 日期段标题（与 rules-layer.js 的 DATE_SECTION_RE 同口径）。 */
+export const RULE_DATE_SECTION_RE_V1 = /^##\s*\d{4}-\d{2}-\d{2}\s*$/
+
+/** 条目行：允许前导缩进 + `- `（渲染器同样只看 `- ` 行）。 */
+export const RULE_ITEM_RE_V1 = /^(\s*)-\s+(.*)$/
+
+/** 单条规则长度上限（与写闸门同量级，防止一次塞进整篇文档）。 */
+export const RULE_ITEM_MAX_CHARS_V1 = 2000
+
+/**
+ * 列出所有规则条目（**行号从 0 开始**，供后续增删改定位）。
+ *
+ * @param {string} text  MEMORY.md 全文
+ * @returns {Array<{line:number, indent:string, text:string, source:string, dateSection:string|null}>}
+ */
+export function listRuleItemsPre(text) {
+  const lines = String(text == null ? '' : text).split(/\r?\n/)
+  const out = []
+  let curDate = null
+  for (let i = 0; i < lines.length; i++) {
+    const l = lines[i]
+    if (RULE_DATE_SECTION_RE_V1.test(l)) { curDate = l.replace(/^##\s*/, '').trim(); continue }
+    const m = RULE_ITEM_RE_V1.exec(l)
+    if (!m) continue
+    const body = m[2].trim()
+    if (!body) continue
+    out.push({
+      line: i,
+      indent: m[1] || '',
+      text: body,
+      // 落在日期段内 ⇒ 多为 AI（memory_user 会带日期标题）写入；否则视为用户手写
+      source: curDate ? 'ai' : 'user',
+      dateSection: curDate,
+    })
+  }
+  return out
+}
+
+/** 内部：切行（保留原始行尾风格判定所需的信息交给 join 处理）。 */
+function splitLinesPre(text) { return String(text == null ? '' : text).split(/\r?\n/) }
+
+function joinLinesPre(lines) { return lines.join('\n') }
+
+/**
+ * **替换**第 idx 条规则（按 listRuleItemsPre 的顺序）。
+ *
+ * @returns {{ok:boolean, text?:string, error?:string}}
+ */
+export function updateRuleItemPre(text, idx, nextBody) {
+  const items = listRuleItemsPre(text)
+  const body = String(nextBody == null ? '' : nextBody).trim()
+  if (!Number.isInteger(idx) || idx < 0 || idx >= items.length) return { ok: false, error: 'index-out-of-range' }
+  if (!body) return { ok: false, error: 'empty-body' }
+  if (body.length > RULE_ITEM_MAX_CHARS_V1) return { ok: false, error: 'too-long' }
+  if (/\r|\n/.test(body)) return { ok: false, error: 'multiline-not-allowed' }
+  const lines = splitLinesPre(text)
+  const it = items[idx]
+  lines[it.line] = it.indent + '- ' + body
+  return { ok: true, text: joinLinesPre(lines) }
+}
+
+/**
+ * **删除**第 idx 条规则（真删，见 R7-4）。
+ *
+ * ⚠️ 本层渲染器（`renderRulesSectionPre`）不认任何状态标记 ⇒ 软删标记会被当正文注入模型；
+ *    故这里**直接移除该行**。不可撤销 —— 调用方必须做二次确认。
+ */
+export function removeRuleItemPre(text, idx) {
+  const items = listRuleItemsPre(text)
+  if (!Number.isInteger(idx) || idx < 0 || idx >= items.length) return { ok: false, error: 'index-out-of-range' }
+  const lines = splitLinesPre(text)
+  lines.splice(items[idx].line, 1)
+  return { ok: true, text: joinLinesPre(lines) }
+}
+
+/**
+ * **追加**一条规则。
+ *
+ * 落点规则（与用户手写习惯一致，且保证渲染器一定能读到）：
+ *   - `dateSection` 为空 ⇒ 追加到**文件头部**（用户手写区，`source` 会是 `user`）；
+ *   - 给了 `dateSection` ⇒ 追加到该日期段的**末尾**（AI 写入区）。
+ */
+export function appendRuleItemPre(text, body, opts = {}) {
+  const b = String(body == null ? '' : body).trim()
+  if (!b) return { ok: false, error: 'empty-body' }
+  if (b.length > RULE_ITEM_MAX_CHARS_V1) return { ok: false, error: 'too-long' }
+  if (/\r|\n/.test(b)) return { ok: false, error: 'multiline-not-allowed' }
+  const lines = splitLinesPre(text)
+  const want = opts && opts.dateSection ? String(opts.dateSection).trim() : ''
+  const newLine = '- ' + b
+  if (!want) {
+    // 头部插入：跳过开头的空行，避免把条目顶到文件最上面的空行之前
+    let at = 0
+    while (at < lines.length && lines[at].trim() === '') at++
+    lines.splice(at, 0, newLine)
+    return { ok: true, text: joinLinesPre(lines) }
+  }
+  // 找目标日期段，插到该段内最后一个非空行之后
+  let secAt = -1
+  for (let i = 0; i < lines.length; i++) {
+    if (RULE_DATE_SECTION_RE_V1.test(lines[i]) && lines[i].replace(/^##\s*/, '').trim() === want) { secAt = i; break }
+  }
+  if (secAt < 0) return { ok: false, error: 'date-section-not-found' }
+  let end = secAt + 1
+  while (end < lines.length && !RULE_DATE_SECTION_RE_V1.test(lines[end])) end++
+  let ins = end
+  while (ins > secAt + 1 && lines[ins - 1].trim() === '') ins--
+  lines.splice(ins, 0, newLine)
+  return { ok: true, text: joinLinesPre(lines) }
+}
+
+/**
+ * **预览**：把规则条目渲染成注入时会长的样子（R7-6）。
+ *
+ * 只做**只读**格式化，不引入 rules-layer.js 的其它依赖（避免循环 import 风险）。
+ */
+export function previewRulesPre(text) {
+  const items = listRuleItemsPre(text)
+  return items.map((x) => '- ' + x.text).join('\n')
+}
+
+/** 空规则段判定（给 UI 显示空态用）。 */
+export function isEmptyRulesPre(text) { return listRuleItemsPre(text).length === 0 }
+

package/lib/semantic-decide.js

@@ -27,16 +27,49 @@ const PLAN_TOKENS = ['准备', '打算', '计划', '之后', '接下来', '继
 const WS_RUN = /\s\s+/g
 // Python `(?u)\b\w\w+\b` 中 \w 含 CJK;JS 的 \w 默认只含 ASCII,须显式加 CJK
 // 否则中文词不被切分 → 无 gram → 中文意图全靠 intercept(严重偏差)。
-const WORD_RE = /[A-Za-z0-9_\u4e00-\u9fff]+/g
+// ★ issue #68 修复（2026-09-19）：**加 `{2,}` 下限** —— Python 侧是 `\b\w\w+\b`（**≥2 字**），
+//   旧实现允许 1 字词（`+`）⇒ 中文单字（如「好」「是」）在 JS 侧会生成 gram、Python 侧不会，
+//   两版对**同一输入**给出不同 gram 集合 ⇒ 判定分叉。
+const WORD_RE = /[A-Za-z0-9_\u4e00-\u9fff]{2,}/g
+
+/**
+ * 与 Python `normalize_text` 逐字对齐。
+ * ★ issue #68 修复（2026-09-19）：旧实现有三处分叉，现全部按 **Python 为权威** 对齐：
+ *   ① **整删非字母数字**：旧实现 `.replace(/[^…\s]/g, ' ')` 把标点变**空格** ⇒ `"a-b"` 得到 `"a b"`（两词），
+ *      而 Python 是 `''.join(ch for ch in text.lower() if ch.isalnum() or CJK)` ⇒ `"ab"`（**一词**）；
+ *   ② **`isalnum()` 语义**：Python 的 `str.isalnum()` 对**全角数字**（`１２３`）、带音标字母（`é`）为真，
+ *      而 JS 正则 `[a-z0-9]` 只认 ASCII ⇒ 这类字符在 JS 侧被丢弃、Python 侧保留；
+ *   ③ **不再额外压空白**：Python 整删后**不插空格**，故 `"a  b"` → `"a  b"`（原样）而非 `"a b"`。
+ *   修法用 `codePointAt` + `isAlnumPythonish()` 复刻 `isalnum()`，而不是改正则字符类。
+ */
+function isAlnumPythonish(cp) {
+  // ASCII 字母数字
+  if (cp >= 0x30 && cp <= 0x39) return true // 0-9
+  if (cp >= 0x61 && cp <= 0x7a) return true // a-z（已 lower）
+  if (cp >= 0x41 && cp <= 0x5a) return true // A-Z（防御：未 lower 时）
+  // CJK 统一表意文字（与既有 \u4e00-\u9fff 口径一致）
+  if (cp >= 0x4e00 && cp <= 0x9fff) return true
+  // 全角数字 ０-９
+  if (cp >= 0xff10 && cp <= 0xff19) return true
+  // 全角字母 ａ-ｚ / Ａ-Ｚ（★ 首轮遗漏：`toLowerCase()` 会把 Ａ(U+FF21) 折叠成 ａ(U+FF41)，
+  // 若只覆盖数字，全角字母会在折叠后**整段消失**，与 Python `isalnum()` 仍为真的语义分叉）
+  if (cp >= 0xff21 && cp <= 0xff3a) return true // Ａ-Ｚ（防御：未 lower 时）
+  if (cp >= 0xff41 && cp <= 0xff5a) return true // ａ-ｚ（lower 后的实际落点）
+  // 拉丁补充字母（含 é 等带音标字符，覆盖 Latin-1 Supplement 的字母区）
+  if (cp >= 0x00c0 && cp <= 0x00ff && cp !== 0x00d7 && cp !== 0x00f7) return true
+  if (cp >= 0x0100 && cp <= 0x017f) return true // Latin Extended-A
+  return false
+}
 
-/** 与 Python normalize_text 对齐(大小写折叠 + 保留 [a-z0-9]+CJK + 去其他)。 */
 function normalizeText(text) {
-  return String(text || '')
-    .toLowerCase()
-    .replace(WS_RUN, ' ')
-    // 保留字母数字与 CJK,其余变空格(近似 Python 的 keep [a-z0-9] and CJK)
-    .replace(/[^a-z0-9\u4e00-\u9fff\s]/g, ' ')
-    .trim()
+  const lower = String(text || '').toLowerCase()
+  let out = ''
+  // 按码点遍历（避免代理对拆断），复刻 Python 的 `if ch.isalnum()` 整删语义
+  for (const ch of lower) {
+    const cp = ch.codePointAt(0)
+    if (isAlnumPythonish(cp)) out += ch
+  }
+  return out
 }
 
 /** char_wb n-gram 计数(与 Python _char_wb_ngram_counts 对齐)。 */