@a9i5k4/dsh-auto-memory 3.0.1 → 3.1.0

package/lib/memory-hub.js

@@ -70,7 +70,7 @@ export function createMemoryHubPre(opts = {}) {
     : (createProcedureStorePre ? createProcedureStorePre({ now: nowFn }) : null)
 
   const cfg = opts.config || {}
-  const stats = { judgedRows: 0, consumedSemantic: 0, consumedProcedure: 0, consumedEpisodic: 0, skipped: 0, checklistsRendered: 0 }
+  const stats = { judgedRows: 0, consumedSemantic: 0, consumedProcedure: 0, consumedEpisodic: 0, rejectedSemantic: 0, rejectedProcedure: 0, skipped: 0, checklistsRendered: 0 }
 
   // ---- 1) 消费 judgement-shadow(喂给对应 store) ----
   function ingestJudgement(row) {
@@ -87,16 +87,36 @@ export function createMemoryHubPre(opts = {}) {
           : factCandidateFromRow(row)
         if (!cand) { stats.skipped++; return { skipped: true, reason: 'not-fact' } }
         const r = cand._suggestion === 'supersede_suggest' ? stores.facts.supersede(cand) : stores.facts.upsert(cand)
-        stats.consumedSemantic++
-        return { consumed: 'semantic', outcome: r.outcome }
+        // ★2026-09-22（B-3 对齐）：事实入口判据上线后 `upsert` **会**返回 `ok:false`（不是事实陈述 /
+        //   缺字段等）。旧实现在此**无条件** `consumedSemantic++` 并回 `{consumed:'semantic'}`，
+        //   于是宿主日志（index.js hubFeedTick 里 `if (r.consumed) fed++`）与 `?action=feed` 端点
+        //   都把「被拒收」读成「已喂进去」 ⇒ 诊断面在说谎。
+        //   本次只对齐口径（与下方 episodic 分支「如实区分」的既有纪律一致）：**不改任何入库行为**，
+        //   拒收照样拒收，只是不再记成 consumed，并把 code/message 一路透传给人看。
+        const accepted = r.ok !== false
+        if (accepted) stats.consumedSemantic++
+        else { stats.rejectedSemantic++; stats.skipped++ }
+        if (!accepted) {
+          const out = { skipped: true, reason: 'rejected-semantic', outcome: r.outcome, accepted: false }
+          if (r.code) out.code = r.code
+          if (r.message) out.message = r.message
+          return out
+        }
+        return { consumed: 'semantic', outcome: r.outcome, accepted: true }
       }
       if (layer === 'procedure' && stores.procedures) {
         // 从 row 构造 procedure candidate(行内可能只有 sourceIds + 摘要)
         const cand = procedureCandidateFromRow(row)
         if (!cand) { stats.skipped++; return { skipped: true, reason: 'not-procedure' } }
         const r = stores.procedures.observe(cand)
-        stats.consumedProcedure++
-        return { consumed: 'procedure', outcome: r.ok ? 'observed' : r.reason }
+        // ★2026-09-22：与上面 semantic 分支同一口径 —— 观察被拒（非法命令/已弃用等）不算「已消费」，
+        //   否则诊断面同样会把拒收读成成功。不改 observe 的任何入库行为。
+        const accepted = r.ok !== false
+        if (accepted) stats.consumedProcedure++
+        else { stats.rejectedProcedure++; stats.skipped++ }
+        return accepted
+          ? { consumed: 'procedure', outcome: 'observed', accepted: true }
+          : { skipped: true, reason: 'rejected-procedure', outcome: r.reason, accepted: false }
       }
       if (layer === 'episodic' && stores.episodic) {
         // ★ 2026-09-19 上游 PR #77 / issue #63 同步落地（**P0 数据丢失**）：
@@ -243,6 +263,18 @@ export function createMemoryHubPre(opts = {}) {
               promotion = stores.procedures.evaluatePromotion
                 ? stores.procedures.evaluatePromotion(p.procedureId)
                 : null
+              // ★A/B（2026-09-22）：把「人工能否越过」并进**同一条**只读投影。
+              //   界面据此决定要不要给「强制晋升（人工）」按钮：只有统计门拦时才给，
+              //   结构门拦时不给（避免再造一个「点了没反应」的假通道 —— 那正是 A-9 收掉旧按钮的原因）。
+              //   注意：**不改 evaluatePromotion 的签名与函数体**（smoke-test-r2-promotion-pre.mjs
+              //   用字面正则锁签名、用源码切片锁门限顺序）；promotionOverrideView 只读、只复用其结论。
+              if (promotion && stores.procedures.promotionOverrideView) {
+                const ov = stores.procedures.promotionOverrideView(p.procedureId)
+                if (ov && ov.ok !== false) {
+                  promotion.overridable = ov.overridable === true
+                  promotion.gateKind = ov.gateKind
+                }
+              }
             } catch (_) { promotion = null }
             return {
               procedureId: p.procedureId, title: p.title, stage: p.stage, riskLevel: p.riskLevel,

package/lib/note-status.js

@@ -141,7 +141,15 @@ export function statusOfBodyPre(body) {
 export function stripStatusLinePre(body) {
   const s = String(body == null ? '' : body)
   if (!s.includes(NOTE_STATUS_OPEN_V1)) return s
-  return s.split(/\r?\n/).filter((ln) => parseStatusLinePre(ln) === null).join('\n')
+  // ★ 2026-09-21 bugfix(A-4):原实现 `split(/\r?\n/).join('\n')` 会把**所有** CRLF 改写成裸 LF,
+  //   而本函数的调用方 `applyStatusToRecordPre` 作用于**目标条目正文**并回写整篇文档 ⇒
+  //   每次 supersedes/retract/restore 都破坏该条目的行尾,与「除状态行外逐字节保持原样」的
+  //   文档承诺相反;本仓文件全 CRLF,还会连带 recordDigest 漂移、GUI diff 放大。
+  //   修法:**先探测原文换行风格,再按同风格重组** —— 保持行尾不变(纯函数语义也随之更严格)。
+  const nl = s.includes('\r\n') ? '\r\n' : '\n'
+  const kept = s.split(/\r?\n/).filter((ln) => parseStatusLinePre(ln) === null)
+  // 注意:split 后不含行尾符,join 时统一用探测到的风格;末尾空行会被自然保留(与 split 前条目数一致)
+  return kept.join(nl)
 }
 
 /**

package/lib/procedure-store.js

@@ -7,15 +7,43 @@ import { isObservationOnlyPre, normalizeProcedureObservationPre, matchingProcedu
  * ★ 这是「记忆中枢」的核心价值层:把多次使用的固定流程固化成 skill,
  *   让 M7 记忆召回系统在相似场景自动召回这些 skill,AI 按固定流程执行。
  *
- * 生命周期状态机(M-04 元代码逐行落地):
- *   observed → candidate → validated → active → deprecated
+ * 生命周期状态机(M-04 元代码逐行落地;P2-3 收敛为两态跳变):
+ *   observed → validated → active → deprecated
+ *   注:原枚举含 `candidate`,但全仓**无任何** stage='candidate' 写入点(observe 只产 observed、
+ *   promote 直接 observed→validated)⇒ 它是死状态,已从枚举移除;旧快照若含该 stage,
+ *   restore() 按"两态跳变"语义归入 observed(不静默丢弃)。
  *
  * 晋升规则(promote, 元代码原样):
  *   - sessionDiversity ≥ 3(跨独立会话)且 successCount ≥ 2 → 可晋升
- *   - correctionRate > MAX_CORRECTION 或 contradictions → 保持 candidate
- *   - 无 successCriteria 或 无 cross-session evidence → 保持 candidate
- *   - riskLevel=high 且未用户批准 → 返回 {action:'ask'} 等待批准
+ *   - correctionRate > MAX_CORRECTION 或 contradictions → 保持 observed
+ *   - 无 successCriteria 或 无 cross-session evidence → 保持 observed
+ *   - riskLevel=high 且未用户批准 → 返回 {decision:'ask'} 等待批准
  *   - 一次成功或三次重复均不足以证明可靠(元代码铁律)
+ *
+ * ★ ok 与 promoted 的语义差异(P2-5,2026-09-21):
+ *   promote() 的 `ok` 只表示**这次调用被正常处理**(未抛错、未命中 disposed/not-found),
+ *   **拒绝晋升同样是 ok:true**;要判断"到底晋升了没有"必须读 `promoted`(boolean)。
+ *   加这个字段的原因:宿主 lib/index.js:10934-10936 记录过该坑 —— 旧日志只记 `r.ok`,
+ *   于是"拒绝晋升"与"晋升成功"都写成 ok:true 的假阳性,事后完全看不出是否晋升。
+ *   `ok` 语义保持不变(兼容既有调用方);新增调用方请以 `promoted` 为准。
+ *
+ * ★ 落盘失败可见(A-8,2026-09-21):
+ *   凡走 persist() 的写操作,返回值都带 `persisted:boolean`;为 false 时附
+ *   `persistReason` 与 `persistFailures`,getStats() 另透出 `persistFailures`/`lastPersistError`。
+ *   此前 persist() 用**空 catch** 吞掉落盘失败 ⇒ 写盘坏了无从察觉(本模块零依赖、不打日志,
+ *   故只能靠返回值与 stats 留痕)。
+ *
+ * ★ 人工批准只解一道门(B-1,2026-09-21):
+ *   高风险条目入库时 `approved = c.riskLevel !== 'high'` ⇒ 恒为 false,而在此之前**全仓没有任何代码**
+ *   能把它置真 ⇒ promote() 走到高风险门只能返回 `{decision:'ask', reasonCodes:['high-risk-awaiting-approval']}`,
+ *   高风险技能永远晋升不了(死路)。`approve(procedureId, by)` 就是那条唯一的解门通路:
+ *     · 它**只**置 `approved/approvedAt/approvedBy/updatedAt` 并落盘 —— 不改 stage、不触发晋升;
+ *     · 它**不跳过** promote() 的另外五道结构门(已弃用短路 / 纯观察行短路 / 缺 successCriteria /
+ *       纠正率超限 / 存在纠正记录):批准后仍可能被这些门拒绝,必须再调 promote() 才知道最终结果;
+ *     · 所以 `approved:true` 的语义是**"高风险这道门不再拦"**,不是"这条已晋升/已激活"。
+ *   返回的 `reason` 一律取自**冻结的机器码集合**(`not-found` / `stage-deprecated` / `disposed`),
+ *   人类可读文案由消费端(前端/工具文案层)做映射 —— 码值稳定可枚举,不随文案变化。
+}
  *
  * 渐进激活(M6 六级 level):
  *   index → hint → excerpt → checklist → resource → full
@@ -37,13 +65,14 @@ export const PROCEDURE_POLICY_VERSION = 'procedure_store_v1'
 export const PROCEDURE_ID_PREFIX = 'proc_'
 export const PROCEDURE_ID_RE = /^proc_[0-9a-f]{32}$/
 
-/** 阶段枚举(M-04 元代码)。 */
-export const PROCEDURE_STAGES_V1 = Object.freeze(['observed', 'candidate', 'validated', 'active', 'deprecated'])
+/** 阶段枚举(M-04 元代码)。P2-3:移除死状态 'candidate' —— 全仓无写入点,
+ *  observe 只产 observed、promote 直接 observed→validated(两态跳变)。 */
+export const PROCEDURE_STAGES_V1 = Object.freeze(['observed', 'validated', 'active', 'deprecated'])
 
 /** 自动归档老化(Hermes curator 借鉴,2026-08-28):active 技能 lastUsedAt 超过
  *  PROCEDURE_ARCHIVE_AFTER_DAYS_V1 天未使用且未 pinned → 自动 deprecated
  *  (reason=auto-archive-inactive;deprecated 可恢复,永不物理删除)。
- *  observed/candidate/validated 不老化——它们由晋升门槛时间控。 */
+ *  observed/validated 不老化——它们由晋升门槛时间控(P2-3 后已无 candidate 态)。 */
 export const PROCEDURE_ARCHIVE_AFTER_DAYS_V1 = 90
 
 /** 风险等级枚举。 */
@@ -89,6 +118,20 @@ export function validateProcedurePre(p) {
   if (p.lastUsedAt !== undefined && (typeof p.lastUsedAt !== 'number' || !Number.isFinite(p.lastUsedAt))) q.push('lastUsedAt')
   if (p.pinned !== undefined && typeof p.pinned !== 'boolean') q.push('pinned')
   if (p.origin !== undefined && !['agent', 'user'].includes(p.origin)) q.push('origin')
+  // ★A-6(2026-09-21):evidence 形状校验。此前清单里**没有 evidence** ⇒
+  //   ① 缺键时 promote() 的 `ev.seen + ev.read + …` 得 NaN,`NaN > cap` 为 false **静默放行**;
+  //   ② evidence 整个缺失时 addEvidence 抛 TypeError,被宿主 lib/index.js:7644 空 catch 吞掉。
+  //   兼容策略:**存在即须为对象且各计数为有限数;缺失不 reject**(旧快照本就无此字段),
+  //   由 restore()/addEvidence() 用 normalizeEvidencePre 补零 —— 比"拒绝入袋"更安全(不丢条目)。
+  if (p.evidence !== undefined) {
+    if (!p.evidence || typeof p.evidence !== 'object' || Array.isArray(p.evidence)) q.push('evidence')
+    else {
+      for (const k of ['seen', 'read', 'cite', 'reuse', 'success', 'correction', 'sessions']) {
+        const vv = p.evidence[k]
+        if (vv !== undefined && (typeof vv !== 'number' || !Number.isFinite(vv))) q.push('evidence.' + k)
+      }
+    }
+  }
   if (q.length) return { ok: false, reason: 'invalid:' + q.join(',') }
   return { ok: true, procedure: p }
 }
@@ -130,7 +173,28 @@ export function createProcedureStorePre(opts = {}) {
 
   let procedures = []      // 全部 procedure(各 stage)
   let disposed = false
-  const stats = { observed: 0, candidates: 0, validated: 0, activated: 0, deprecated: 0, approvalAsked: 0 }
+  // P2-3:删除死字段 stats.candidates —— 全仓无 stage='candidate' 写入点,该计数永远为 0。
+  // B-1(2026-09-21):approved = **真的写下去**的人工批准次数(只统计 approve() 的写入分支;
+  //   notRequired / alreadyApproved 是幂等空操作,不计数 —— 它们没有新增任何批准留痕)。
+  const stats = { observed: 0, validated: 0, activated: 0, deprecated: 0, approvalAsked: 0, approved: 0 }
+  // A-8:落盘失败痕迹(本模块零依赖不打日志,故只能留在这里供 getStats() 透出)。
+  let persistFailures = 0
+  let lastPersistError = null
+
+  /** 证据计数键与回填函数(A-6)。放模块级以免每次调用重建闭包。 */
+  function emptyEvidencePre() {
+    return { seen: 0, read: 0, cite: 0, reuse: 0, success: 0, correction: 0, sessions: 0 }
+  }
+  function normalizeEvidencePre(ev) {
+    const out = emptyEvidencePre()
+    if (ev && typeof ev === 'object' && !Array.isArray(ev)) {
+      for (const k of Object.keys(out)) {
+        const v = ev[k]
+        if (typeof v === 'number' && Number.isFinite(v)) out[k] = v
+      }
+    }
+    return out
+  }
 
   function defaultProcedureId(title, createdAt) {
     const h = createHash('sha256').update(['procedure-v1', String(title), String(createdAt)].join('\u0000')).digest('hex')
@@ -203,6 +267,10 @@ export function createProcedureStorePre(opts = {}) {
     if (!ev || typeof ev !== 'object' || !['seen', 'read', 'cite', 'reuse', 'success', 'correction'].includes(ev.kind)) {
       return { ok: false, reason: 'bad-evidence' }
     }
+    // ★A-6(2026-09-21)收尾:自增前必须先规范化 —— 旧快照/异常来源可能缺键,
+    //   裸 `p.evidence[ev.kind]++` 会得 NaN(静默污染 promote 的门限算术)或抛 TypeError
+    //   (被宿主 lib/index.js:7644 空 catch 吞掉 ⇒ 表现为「证据永远不累积」且无留痕)。
+    p.evidence = normalizeEvidencePre(p.evidence)
     if (p.evidence[ev.kind] !== undefined) p.evidence[ev.kind]++
     // session 去重
     if (ev.sessionRef) {
@@ -279,46 +347,49 @@ export function createProcedureStorePre(opts = {}) {
    *   并**留痕**：`p.authorizedBy` + reasonCodes 追加 `model-authorized`，供审计与前端展示。
    */
   function promote(procedureId, extraEvidence = {}, opts = {}) {
-    if (disposed) return { ok: false, reason: 'disposed' }
+    if (disposed) return { ok: false, promoted: false, reason: 'disposed' }
     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 (!p) return { ok: false, promoted: false, reason: 'not-found' }
+    if (p.stage === 'deprecated') return { ok: true, promoted: false, decision: 'keep', reasonCodes: ['deprecated'] }
     // issue #30:纯 episode 观察行没有 successCriteria,本来就无法晋升;
     // 显式短路并给出 `observation-only` 原因码,而不是让它落到下面报 `no-success-criteria`
     // (后者会让使用者误以为"缺判据、补上就能晋升",其实是这行**结构上**不该晋升)。
     // ★ T4:此短路**不受授权影响** —— 结构上不该晋升的行,模型授权也不放行。
-    if (isObservationOnlyPre(p)) return { ok: true, decision: 'keep', procedure: p, reasonCodes: ['observation-only'] }
+    if (isObservationOnlyPre(p)) return { ok: true, promoted: false, 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')
+    // ★A/B（2026-09-22）：授权来源分人留痕 —— 人工越权与模型越权必须在审计面可区分。
+    //   注意：此行的形态变化会让 r2 的「源码级原因码提取」不再捕获它（正则要求引号紧跟括号），
+    //   这正是期望的：它本来就属 AUTH_ONLY 集合、需被排除在门限顺序比对之外。
+    if (authorizedBy) reason.push(authorizedBy === 'user' ? 'user-authorized' : 'model-authorized')
     // 跨会话多样性
     const diversity = extraEvidence.distinctSessions != null ? extraEvidence.distinctSessions : ev.sessions
     const successCount = extraEvidence.successCount != null ? extraEvidence.successCount : ev.success
     // ★ 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 } }
+      if (diversity < gates.minSessionDiversity) { reason.push('diversity-below-' + gates.minSessionDiversity); return { ok: true, promoted: false, decision: 'keep', procedure: p, reasonCodes: reason } }
+      if (successCount < gates.minSuccessCount) { reason.push('success-below-' + gates.minSuccessCount); return { ok: true, promoted: false, 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
-    if (corrRate > gates.maxCorrectionRate) { reason.push('correction-rate-' + corrRate.toFixed(2)); return { ok: true, decision: 'keep', procedure: p, reasonCodes: reason } }
+    if (corrRate > gates.maxCorrectionRate) { reason.push('correction-rate-' + corrRate.toFixed(2)); return { ok: true, promoted: false, decision: 'keep', procedure: p, reasonCodes: reason } }
     // contradictions
-    if (gates.maxContradictions === 0 && ev.correction > 0) { reason.push('has-correction'); return { ok: true, decision: 'keep', procedure: p, reasonCodes: reason } }
+    if (gates.maxContradictions === 0 && ev.correction > 0) { reason.push('has-correction'); return { ok: true, promoted: false, decision: 'keep', procedure: p, reasonCodes: reason } }
     // successCriteria 必须有(元代码: 无 successCriteria → keepCandidate)
-    if (!p.successCriteria.length) { reason.push('no-success-criteria'); return { ok: true, decision: 'keep', procedure: p, reasonCodes: reason } }
+    if (!p.successCriteria.length) { reason.push('no-success-criteria'); return { ok: true, promoted: false, decision: 'keep', procedure: p, reasonCodes: reason } }
     // 高风险需批准
     if (p.requiresApproval && !p.approved) {
       if (approveFn) {
         const apr = approveFn(p)
         if (apr && apr.approved) p.approved = true
-        else { stats.approvalAsked++; reason.push('high-risk-awaiting-approval'); return { ok: true, decision: 'ask', procedure: p, reasonCodes: reason } }
+        else { stats.approvalAsked++; reason.push('high-risk-awaiting-approval'); return { ok: true, promoted: false, decision: 'ask', procedure: p, reasonCodes: reason } }
       } else {
         stats.approvalAsked++
         reason.push('high-risk-awaiting-approval')
-        return { ok: true, decision: 'ask', procedure: p, reasonCodes: reason }
+        return { ok: true, promoted: false, decision: 'ask', procedure: p, reasonCodes: reason }
       }
     }
     // 晋升
@@ -329,7 +400,7 @@ export function createProcedureStorePre(opts = {}) {
     if (authorizedBy) p.authorizedBy = authorizedBy
     stats.validated++
     void persist()
-    return { ok: true, decision: 'promote', procedure: p, reasonCodes: reason }
+    return { ok: true, promoted: true, decision: 'promote', procedure: p, reasonCodes: reason }
   }
 
   /**
@@ -386,6 +457,54 @@ export function createProcedureStorePre(opts = {}) {
     return { ok: true, decision: 'promote', reasonCodes: reason, detail: { diversity, successCount } }
   }
 
+  /**
+   * ★A/B（2026-09-22）：**人工可越权性**只读投影 —— 回答「这道 keep 人能不能强制越过」。
+   *
+   * 为什么单独一个函数、而不是给 evaluatePromotion 加参数：
+   *   · `smoke-test-r2-promotion-pre.mjs` 用**字面正则**锁住了 `evaluatePromotion(procedureId)` 的签名，
+   *     并用**源码切片**比对它与 `promote()` 的 reason.push 序列；动它的签名或函数体会同时打红两条守卫。
+   *   · 更要紧的是「不重复实现门限」：本函数**不重写任何一道门**，而是复用 evaluatePromotion 的结论，
+   *     只判断「拦它的原因码里是否**只有**那两道统计门」。
+   *
+   * 语义依据（与 `promote()` 逐条对齐，见 :368 `if (!authorizedBy) {`）：
+   *   · 被授权时**只**跳过 `diversity-below-*` 与 `success-below-*` 两道统计门；
+   *   · 结构门（deprecated / observation-only / correction-rate-* / has-correction /
+   *     no-success-criteria / high-risk-awaiting-approval）**授权也拦**
+   *     ⇒ 只要原因码里出现其中任何一个，就**不可越权**（界面上不该给强制按钮）。
+   *
+   * 纯只读：只调 evaluatePromotion，不写盘、不改状态、不动统计。异常一律 fail-soft 返回不可越权。
+   *
+   * @param {string} procedureId
+   * @returns {{ok:boolean, decision?:string, overridable:boolean, reasonCodes?:string[], gateKind?:string}}
+   *          `gateKind`：`promote`（已可晋升，无需越权）/ `statistical`（仅统计门拦，可人工越权）/
+   *          `structural`（结构门拦，人工也不放行）/ `unknown`（投影失败）
+   */
+  function promotionOverrideView(procedureId) {
+    try {
+      const view = evaluatePromotion(procedureId)
+      if (!view || view.ok === false) return { ok: false, overridable: false, gateKind: 'unknown' }
+      if (view.decision === 'promote') {
+        return { ok: true, decision: 'promote', overridable: false, gateKind: 'promote', reasonCodes: view.reasonCodes || [] }
+      }
+      if (view.decision === 'ask') {
+        // 高风险待批准：本来就有人工通路（approve），不该再给"强制晋升"。
+        return { ok: true, decision: 'ask', overridable: false, gateKind: 'structural', reasonCodes: view.reasonCodes || [] }
+      }
+      const codes = Array.isArray(view.reasonCodes) ? view.reasonCodes : []
+      const isStat = (c) => /^diversity-below-/.test(c) || /^success-below-/.test(c)
+      const stat = codes.length > 0 && codes.every(isStat)
+      return {
+        ok: true,
+        decision: 'keep',
+        overridable: stat,
+        gateKind: stat ? 'statistical' : 'structural',
+        reasonCodes: codes,
+      }
+    } catch (_) {
+      return { ok: false, overridable: false, gateKind: 'unknown' }
+    }
+  }
+
   /** 激活: validated → active(可被召回)。 */
   function activate(procedureId) {
     const p = procedures.find((x) => x.procedureId === procedureId)
@@ -398,6 +517,56 @@ export function createProcedureStorePre(opts = {}) {
     return { ok: true, procedure: p }
   }
 
+  /**
+   * ★B-1(2026-09-21):**人工批准原语** —— 只解「高风险需人工确认」这一道门。
+   *
+   * 为什么需要它(取证):高风险条目入库时 `approved = c.riskLevel !== 'high'`(observe, :235)
+   * 恒为 false,而在本函数之前**全仓没有任何代码能把它置真**:promote() 走到高风险门只会返回
+   * `{decision:'ask', reasonCodes:['high-risk-awaiting-approval']}`(宿主建 store 未传 opts.approve,
+   * 路由白名单也没有 approve 动作)⇒ 高风险技能的晋升是**死路**。本函数就是那条唯一通路。
+   *
+   * 边界(**只有一道门**;文件头同名小节是同一条约定):
+   *   · 只置 `approved/approvedAt/approvedBy/updatedAt` 并落盘 —— **不改 stage、不触发晋升、不写 authorizedBy**;
+   *   · **不跳过** promote() 的另外五道结构门(已弃用短路 / 纯观察行短路 / 缺 successCriteria /
+   *     纠正率超限 / 存在纠正记录)⇒ 批准之后仍可能被这些门拒绝,必须再调 promote() 才知道结果;
+   *   · 所以返回里的 `approved:true` 意思是**"高风险这道门不再拦"**,不是"这条已晋升/已激活"。
+   *     前端要展示"已批准、待晋升"时请读 `procedure.approved`,不要拿它当 stage 用。
+   *
+   * 幂等:重复调用不重复写盘,也不覆盖首次的 approvedAt/approvedBy(批准留痕不可被后续调用改写)。
+   * 失败码一一取自**冻结的机器码集合**(`not-found` / `stage-deprecated` / `disposed`);人类可读
+   * 文案由消费端(前端 / 工具文案层)映射 —— 码值稳定可枚举,不随文案措辞变化。
+   *
+   * @param {string} procedureId
+   * @param {string} [by='user'] 批准者标识(用户手动=user;宿主/模型代批可传其它值,原样记入 approvedBy)
+   * @returns {{ok:boolean, approved:boolean, reason?:string, notRequired?:boolean, alreadyApproved?:boolean, persisted?:boolean, procedure?:object}}
+   */
+  function approve(procedureId, by = 'user') {
+    if (disposed) return { ok: false, reason: 'disposed' }
+    const p = procedures.find((x) => x.procedureId === procedureId)
+    if (!p) return { ok: false, reason: 'not-found' }
+    // 已弃用:更强的短路,先判 —— 弃用条目不该被"批准"(批准不改变它的命运,只可能造出误导性留痕)。
+    // 冻结码 'stage-deprecated' 与 activate()/deprecate() 的 'stage-' + stage 同形,前端可统一映射。
+    if (p.stage === 'deprecated') return { ok: false, reason: 'stage-deprecated', procedure: p }
+    // 本就不需要批准(requiresApproval 为 false,含旧快照缺该字段的行 —— 判据与 promote() 一致):
+    // **纯只读返回**:不写盘、不动状态。没有门可解,写 approved 只会伪造一条"有人批过"的留痕。
+    if (!p.requiresApproval) return { ok: true, approved: true, notRequired: true, procedure: p }
+    // 幂等:已批准过 —— 不重复写盘,也不覆盖首次的 approvedAt/approvedBy。
+    if (p.approved) return { ok: true, approved: true, alreadyApproved: true, procedure: p }
+    const now = nowFn()
+    p.approved = true
+    p.approvedAt = now
+    p.approvedBy = String(by)
+    p.updatedAt = now
+    stats.approved++
+    const r = persist()
+    // A-8 同口径:落盘失败**不静默** —— ok 仍为 true(内存里这道门确实开了),但把失败痕迹透出,
+    // 由调用方决定是否上报(persisted:false 时附 persistReason/persistFailures)。
+    // 键序与冻结契约一致(ok/approved/persisted/procedure),附加字段只出现在失败时。
+    const out = { ok: true, approved: true, persisted: r.ok, procedure: p }
+    if (!r.ok) { out.persistReason = r.reason; out.persistFailures = r.persistFailures }
+    return out
+  }
+
   /** 降级/禁用: 任何 stage → deprecated(用户手动或 correction 爆表)。 */
   function deprecate(procedureId, reason = 'user-disabled') {
     const p = procedures.find((x) => x.procedureId === procedureId)
@@ -433,6 +602,23 @@ export function createProcedureStorePre(opts = {}) {
    * 输出给 M7 召回系统:相似场景召回 active procedure → 注入 checklist 提示 AI 按固定流程走。
    * 高风险 → 降级为 hint(仅提示"可参考流程",不自动给步骤)。
    */
+  /**
+   * ★P2-7(2026-09-21):checklist 行 → 注入文本,**超长截断必须可见**。
+   *
+   * 旧实现 `lines.join('\n').slice(0, 2000)` 在超长时**静默**丢掉尾部 ——
+   * 而注入文本的尾部恰好是「检查 / 完成标准 / 回滚」,模型据此判断不了
+   * "这条技能是否被砍过",也就无从知道该不该照做。本仓既有口径是
+   * 「裁剪永远可见」(见 memory-envelope-pre 的同类处理),此处对齐。
+   */
+  function renderChecklistTextPre(lines) {
+    const full = lines.join('\n')
+    const CAP = 2000
+    if (full.length <= CAP) return full
+    const droppedChars = full.length - CAP
+    return full.slice(0, CAP)
+      + '\n…(清单超长已截断:尾部 ' + droppedChars + ' 字符未展开,可能含检查/完成标准/回滚,共 ' + lines.length + ' 段)'
+  }
+
   function renderChecklist(procedureId) {
     const p = procedures.find((x) => x.procedureId === procedureId)
     if (!p || p.stage !== 'active') return null
@@ -451,7 +637,7 @@ export function createProcedureStorePre(opts = {}) {
     if (p.rollback.length) lines.push('回滚: ' + p.rollback.join('; '))
     return {
       procedureId: p.procedureId, title: p.title, level: activeLevel, riskLevel: p.riskLevel,
-      text: lines.join('\n').slice(0, 2000), // 预算内
+      text: renderChecklistTextPre(lines), // ★P2-7(2026-09-21):超长截断必须可见(此前静默砍掉尾部)
     }
   }
 
@@ -468,37 +654,72 @@ export function createProcedureStorePre(opts = {}) {
     if (!Array.isArray(data.procedures)) return { ok: false, reason: 'bad-procedures' }
     procedures = []
     for (const p of data.procedures) {
-      const v = validateProcedurePre(p)
+      // P2-3:旧快照可能含已移除的 'candidate' 态 —— 按"两态跳变"语义归入 observed(不丢条目)。
+      const migrated = p && p.stage === 'candidate' ? { ...p, stage: 'observed' } : p
+      const v = validateProcedurePre(migrated)
       if (!v.ok) continue
-      if (p._sessions) { p._sessions = new Set(p._sessions); p.evidence.sessions = p._sessions.size }
+      // A-6:evidence 回填为有限数(缺键/脏值按 0)——否则 promote 的门限算术会得 NaN 而静默放行。
+      v.procedure.evidence = normalizeEvidencePre(v.procedure.evidence)
+      if (migrated._sessions) {
+        v.procedure._sessions = new Set(migrated._sessions)
+        v.procedure.evidence.sessions = v.procedure._sessions.size
+      }
       // issue #30:旧快照里没有 observationOnly 字段,恢复时按同一判据补齐
       // (纯增量元数据迁移:不改身份/文本/风险/证据/阶段)。
       procedures.push(normalizeProcedureObservationPre(v.procedure))
     }
+    // ★B-1(2026-09-21):stats.approved 是本轮新增计数,旧快照(以及本模块自己的快照 ——
+    //   snapshot() 不含 stats 字段)里都没有这个键。还原后它**必须仍是有限数**:getStats() 是
+    //   前端计数面板的数据源,透出 undefined 会让「已批准 N 条」凭空消失,而各消费方的兜底
+    //   写法又不一致。有快照值就用快照值(数字/数字串都收),没有或脏值则保留当前值兜底 ——
+    //   不无脑清零:restore() 并不还原其它统计(observed/validated/...),单清一个反而更不一致。
+    stats.approved = Number(data.stats && data.stats.approved) || Number(stats.approved) || 0
     return { ok: true, restored: procedures.length }
   }
+  /** 清空(失败不再静默:io.clear 抛错时返回 ok:false + error)。 */
   function clear() {
     procedures = []
-    try { io.clear() } catch (_) {}
+    try { if (typeof io.clear === 'function') io.clear() } catch (e) {
+      return { ok: false, reason: 'io-clear-failed', error: String((e && e.message) || e) }
+    }
     return { ok: true }
   }
+  /** 处置:落盘一次(与 persist 同口径返回,失败可见)。保留 reason 形参以兼容宿主既有调用。 */
   function dispose(reason) {
-    if (disposed) return
+    if (disposed) return { ok: true, alreadyDisposed: true, persisted: true }
     disposed = true
-    try { io.save(snapshot()) } catch (_) {}
+    const r = persist()
+    if (reason) r.disposeReason = String(reason)
+    return r
   }
+  /**
+   * ★A-8(2026-09-21):落盘并**返回结果**。此前实现是 `try { io.save(...) } catch (_) {}`,
+   * 落盘失败被**完全吞掉** ⇒ 记忆只在内存里、重启即丢,而调用方与统计都看不出异常。
+   * 现在:失败仍不抛(保持既有容错语义),但①计数 persistFailures ②记 lastPersistError
+   * ③把 { persisted:false, ... } 透传给调用它的写操作返回值,由调用方决定是否上报。
+   */
   function persist() {
-    try { io.save(snapshot()) } catch (_) {}
+    try {
+      io.save(snapshot())
+      lastPersistError = null
+      return { ok: true, persisted: true }
+    } catch (e) {
+      persistFailures++
+      lastPersistError = String((e && e.message) || e)
+      return { ok: false, persisted: false, reason: 'persist-failed', error: lastPersistError, persistFailures }
+    }
   }
 
   return {
     // ★R2：只读判定投影（供 overview() 展示「为什么不能晋升」）
     evaluatePromotion,
-    observe, addEvidence, promote, activate, deprecate,
+    promotionOverrideView,
+    observe, addEvidence, promote, activate, deprecate, approve,
     touch, setPinned, applyAutomaticTransitions,
     query, activeProcedures, get, renderChecklist,
     snapshot, restore, clear, dispose,
-    getStats: () => ({ ...stats }),
+    // A-8:persistFailures/lastPersistError 一并透出(落盘健康度可观察)
+    getStats: () => ({ ...stats, persistFailures, lastPersistError }),
     get size() { return procedures.length },
   }
 }

package/lib/procedure-switch.js

@@ -0,0 +1,38 @@
+/**
+ * ★ B-2 修复(2026-09-22)：**procedure 技能生效总闸的语义纠正与兼容层**。
+ *
+ * 背景（代码取证）：
+ * - 旧键 `procedurePromotionEnabled` 的名字/文案是「技能固化与晋升」（client.js:5023），
+ *   但它的**唯一两个消费者**都与"晋升"无关：
+ *     · context-host.js:537   → `skillEnabled = memoryHubEnabled && procedurePromotionEnabled !== false`（决定技能是否**注入上下文**）
+ *     · activation-host.js:330 → `if (procedurePromotionEnabled === false) return null`（决定**主动唤起**这条臂开不开）
+ *   真正的"晋升"由 store 的门限（procedure-store.js）与路由动作决定，与该键无关。
+ * - 它默认 `false`（index.js:546）⇒ **新用户装完即"技能永不生效"，且没有任何提示**。
+ * - 用户硬规则：「单一开关不得顺带改变其他功能的行为」——本键正是反例。
+ *
+ * 纠正方案（**不新增死开关**）：
+ * - 新增 `procedureInjectEnabled`（默认 **true**）作为语义正确的总闸，供上面两个消费者读取。
+ * - 旧键保留为**兼容别名**：新键缺省时按旧键取值，两键都缺省时取 `true`。
+ *   ⇒ 老用户显式关掉过总闸的，行为不翻面（尊重既有选择）；从未设置过的，技能开始正常生效。
+ * - **不建 `procedureAutoPromoteEnabled`**：全仓无任何自动晋升代码路径
+ *   （`applyAutomaticTransitions` 只导出、零调用 —— 见 BUGLIST P2-4），建了它就是死配置。
+ *   "固化"由既有 `hubMechanicalProcedureFeedEnabled`（T10）管，"晋升"由门限 + 路由动作管。
+ *
+ * ⚠️ 本文件是并行开发的**接口契约**：其他文件只允许通过本模块解析该开关，
+ *    不得各自 inline 一份判断（否则又会出现口径漂移）。
+ */
+
+/** 解析「技能注入/唤起总闸」。@param {object} cfg 插件 config（engine.config） @returns {boolean} */
+export function resolveProcedureInjectEnabledPre(cfg) {
+  const c = cfg || {}
+  if (typeof c.procedureInjectEnabled === 'boolean') return c.procedureInjectEnabled
+  // 兼容别名：旧键语义 = 总闸（见文件头取证），保留其显式选择
+  if (typeof c.procedurePromotionEnabled === 'boolean') return c.procedurePromotionEnabled
+  return true
+}
+
+/** 是否仍在使用已弃用的旧键（供设置页/诊断提示"建议迁移"）。 */
+export function usesLegacyProcedureSwitchPre(cfg) {
+  const c = cfg || {}
+  return typeof c.procedureInjectEnabled !== 'boolean' && typeof c.procedurePromotionEnabled === 'boolean'
+}