@a9i5k4/dsh-auto-memory 3.0.1 → 3.1.1

package/lib/index.js

@@ -49,11 +49,17 @@ import { createFactStorePre } from './fact-store.js'
 import { createProcedureStorePre } from './procedure-store.js'
 import { exportSkillForPre, resolveSkillsRootPre } from './skill-export-host.js'
 import { createMemoryHubPre } from './memory-hub.js'
+// ★#110（2026-09-22）：hub 持久化 IO 适配器与其健康度投影（原本内联在本文件里、失败被静默吞掉）。
+import { createHubIoPre, createHubIoHealthPre, hubIoHealthSnapshotPre } from './hub-io.js'
+// ★issue#103：环形 JSONL 增量游标（内容指纹）。见 lib/jsonl-tail-cursor.js 文件头。
+import { createJsonlTailCursorPre } from './jsonl-tail-cursor.js'
+import { createRecallStatsPre } from './recall-stats.js'
 import { pickConsolidationTextPre } from './intent-clean.js'
 // T1-3（2026-09-19）：hubFlushTick 写入前的**内容卫生门**复用 ⑨ 同源清洗器。
 // 必须独占一行（本仓契约守卫以字面量断言既有 import 行，禁止为排版合并）。
 import { stripRuntimeIntentPre, looksRuntimeResiduePre } from './intent-clean-safe.js'
 import { createStorageManagerPre } from './storage-manage.js'
+import { workspaceSlugPre as migrateSlugPre, buildPackPre, validatePackPre, planImportPre, mergeSummaryRecordPre, MIGRATE_PACK_FORMAT_PRE } from './migrate-pack.js'
 import { rankWorkspacesByMemoryRecencyPre } from './ws-overview-rank.js'
 import { scanPluginSubagentSessions, recycleSessions, PLUGIN_LABEL_PREFIX, decodeZstdFrames, decodeZstdFramesHead } from './subagent-gc.js'
 import { parseModelWindowsPre, pickWindowPre, findOfficialContextWindowPre, findSessionModelPre, scanPressureSignalsPre, reusableWindowCachePre, shouldArmAutoContinuePre } from './water-window.js'
@@ -79,6 +85,56 @@ import { writeTextAtomicPreSync, writeTextAtomicPre, readJsonQuarantinePreSync }
 import { WB_SIDECAR_VERSION, buildSidecarEntryPre, rebuildSidecarIndexPre, expandByTagPre, traceByIdPre, applyAnchorsPre, collectAnchorIdsPre, wbRefPre, normalizeRelPathPre, normalizeTitlePre, buildKanbanPre, buildSectionCardsPre, splitSectionsPre, buildKanbanMatrixPre, ledgerDateOfPre, WB_KANBAN_LANES_V1 } from './wb-sidecar.js'
 // P6A 规则层（规则类与参考类分开措辞；规则真源 = 既有用户级记忆，不新增 RULES.md）
 import { extractRulesLayerPre, renderRulesSectionPre, RULES_SECTION_TITLE_V1, RULES_SECTION_GUIDE_V1, REFERENCE_SECTION_GUIDE_V1, LOG_KINDS_V1 } from './rules-layer.js'
+
+/**
+ * ★P9（2026-09-22）：用户级硬性约束的**条目级增删改** —— 前端路由与模型工具共用的**唯一写盘口**。
+ *
+ * 为什么必须存在：[规则 — 用户级硬性约束 · 必须遵守] 段**每轮无条件注入且不参与裁剪**
+ * （memory-envelope.js 的 rules 分项不受限），而这一层在 P9 之前**认不出状态标记**。
+ * ⇒ 过时条目只能**真删**；而该能力此前只接在前端路由（R7），**模型够不着** ⇒ 模型只能整篇重写
+ * 用户级记忆（高风险、易丢条），或干脆不动 ⇒ 错误规则永久留在每轮 prompt 里。
+ *
+ * 纪律：①真源仍是 userFile，本函数不新增事实来源；②写入复用既有 writeFull 事务（备份 + 校验），
+ * 绝不绕过；③删/改支持 requireExpect **内容锚定**（模型侧强制、GUI 侧沿用 R7 的前端二次确认）。
+ *
+ * @param {object} engine 宿主引擎
+ * @param {string} op list | add | update | remove
+ * @param {object} payload { index?, expect?, text?, dateSection? }
+ * @param {object} [opts] { requireExpect?:boolean }
+ * @returns {Promise<{ok:boolean, error?:string, path?:string, items?:Array, preview?:string}>}
+ */
+async function applyRuleEditPre(engine, op, payload = {}, opts = {}) {
+  const o = String(op || '')
+  if (!['list', 'add', 'update', 'remove'].includes(o)) return { ok: false, error: 'invalid-op' }
+  try {
+    const p = await engine.resolvePaths(undefined)
+    const before = (await engine.readTextSafe(p.userFile)) || ''
+    const view = (text) => {
+      const items = listRuleItemsPre(text)
+      return { ok: true, path: p.userFile, items, preview: items.map((x) => '- ' + x.text).join('\n') }
+    }
+    if (o === 'list') return view(before)
+    // ★内容锚定：删/改前先核对「你认为这条现在是什么」，不符即拒 —— 防索引漂移删错行
+    if (o === 'update' || o === 'remove') {
+      const items0 = listRuleItemsPre(before)
+      const idx = Number(payload.index)
+      if (!Number.isInteger(idx) || idx < 0 || idx >= items0.length) return { ok: false, error: '编辑被拒: index-out-of-range' }
+      if (opts && opts.requireExpect) {
+        const expect = String(payload.expect == null ? '' : payload.expect).trim()
+        if (!expect) return { ok: false, error: '编辑被拒: 缺少 expect（先 op=list 取该条当前文本再回填）' }
+        if (items0[idx].text !== expect) return { ok: false, error: '编辑被拒: expect 与当前第 ' + idx + ' 条不符（内容锚定失败，请重新 list）' }
+      }
+    }
+    let r
+    if (o === 'add') r = appendRuleItemPre(before, payload.text, { dateSection: payload.dateSection })
+    else if (o === 'update') r = updateRuleItemPre(before, Number(payload.index), payload.text)
+    else r = removeRuleItemPre(before, Number(payload.index))
+    if (!r.ok) return { ok: false, error: '编辑被拒: ' + r.error }
+    const written = await engine.writeFull(p.userFile, r.text)
+    const after = (await engine.readTextSafe(p.userFile)) || written || r.text
+    return view(after)
+  } catch (e) { return { ok: false, error: String((e && e.message) || e) } }
+}
 import * as nodeZlib from 'node:zlib'
 import { AsyncLocalStorage } from 'node:async_hooks'
 import { createHash } from 'node:crypto'
@@ -155,7 +211,7 @@ const SECTION_ORDER = 10000
 const NOTICES_URL = 'https://raw.githubusercontent.com/Aik358/dsh-auto-memory/main/notices.json'
 
 /** Model-facing announcement (tools + engine). */
-export const GUIDANCE = '本机已安装 dsh-auto-memory 插件(集中式自动记忆 + 外部记忆继承）：三层本地记忆（用户级 ~/.dsh/memory/MEMORY.md、项目笔记与每日日志 .dsh-memory/）+ 会话自动注入 + 每日反思 + 其他 AI 工具记忆接入。能力：memory_log 追加今日日志（append-only，完成实质性工作后必须调用）；memory_note 更新项目笔记；memory_user 更新用户级规则；memory_recall 检索本地记忆 + 外部记忆（WorkBuddy/CodeBuddy/Claude Code/Codex/ZCode/Kimi Code/TRAE 记忆与会话）+ 历史 DSH 会话；memory_external 查看/接入外部记忆源；memory_maintain 归档 30 天前日志；memory_reflect 保存每日反思；memory_status 查看状态；memory_consolidate 让 AI 读日志发散提炼长期要点固化进笔记。自动沉淀：每轮对话结束插件自动评估本轮内容并写今日日志/升格长期记忆（寒暄轮跳过，间隔与每日额度可在设置页「自动化」分组调整），无需你手动调 memory_log。主动性纪律：任务开始遇到不熟悉的代码/领域/历史决策时，先 memory_recall 检索本机全部 AI 工具历史，不凭空猜测；新工作区主动探索历史。限制：记忆文件为明文 Markdown；不存密钥除非用户明确要求；外部会话检索为关键词级（非语义）；GUI 侧边栏「记忆」面板（含「接续」页签，可查看来源内容、从记忆 prompt 移除已导入段落）与设置页可查看/配置/接入。用户提到「记忆 / 昨天做了什么 / 之前怎么做的 / 每日反思 / 接续 / 其他 AI 的记忆」时即指本插件，请据此协作。白板纪律（三层分工，2026-09-17 定稿）：①**白板 PLAN.md = 项目稳定的"是什么/怎么跑"事实**，由 memory_note(kind=plan) 整体重写（这是 12 个工具里**唯一**能覆盖已有结论的能力，旧版自动归档）；②**交接账本 handoff-*.md = 动态状态的唯一权威**（任务状态/目标/已试方案与失败原因/进度与下一步），由 memory_note(kind=handoff) 新开一篇，**append-only、不追改旧账本**；③**项目笔记 MEMORY.md = 可复用的结论/决策**。维护时机（**条件触发，不是每轮**）：完成阶段性工作、或发现白板/账本所述与现状不符、或方向有实质变化时——**写记忆的同时顺手维护白板**，不要新开一轮专程去做。**禁止**：未得用户同意不得删减白板既有内容（只报告过时，不自动删）；白板/产物功能关闭时跳过白板维护、不要因此报错。'
+export const GUIDANCE = '本机已安装 dsh-auto-memory 插件(集中式自动记忆 + 外部记忆继承）：三层本地记忆（用户级 ~/.dsh/memory/MEMORY.md、项目笔记与每日日志 .dsh-memory/）+ 会话自动注入 + 每日反思 + 其他 AI 工具记忆接入。能力：memory_log 追加今日日志（append-only，完成实质性工作后必须调用）；memory_note 更新项目笔记；memory_user 更新用户级规则（整篇/追加）；memory_rules 对用户级硬约束做**条目级**增删改（op=list/add/update/remove，删改需带 expect 内容锚定；这是清理「每轮必注入的 [规则] 段」过时条目的正确手段）；memory_recall 检索本地记忆 + 外部记忆（WorkBuddy/CodeBuddy/Claude Code/Codex/ZCode/Kimi Code/TRAE 记忆与会话）+ 历史 DSH 会话；memory_external 查看/接入外部记忆源；memory_maintain 归档 30 天前日志；memory_reflect 保存每日反思；memory_status 查看状态；memory_consolidate 让 AI 读日志发散提炼长期要点固化进笔记。自动沉淀：每轮对话结束插件自动评估本轮内容并写今日日志/升格长期记忆（寒暄轮跳过，间隔与每日额度可在设置页「自动化」分组调整），无需你手动调 memory_log。主动性纪律：任务开始遇到不熟悉的代码/领域/历史决策时，先 memory_recall 检索本机全部 AI 工具历史，不凭空猜测；新工作区主动探索历史。限制：记忆文件为明文 Markdown；不存密钥除非用户明确要求；外部会话检索为关键词级（非语义）；GUI 侧边栏「记忆」面板（含「接续」页签，可查看来源内容、从记忆 prompt 移除已导入段落）与设置页可查看/配置/接入。用户提到「记忆 / 昨天做了什么 / 之前怎么做的 / 每日反思 / 接续 / 其他 AI 的记忆」时即指本插件，请据此协作。白板纪律（三层分工，2026-09-17 定稿）：①**白板 PLAN.md = 项目稳定的"是什么/怎么跑"事实**，由 memory_note(kind=plan) 整体重写（这是 12 个工具里**唯一**能覆盖已有结论的能力，旧版自动归档）；②**交接账本 handoff-*.md = 动态状态的唯一权威**（任务状态/目标/已试方案与失败原因/进度与下一步），由 memory_note(kind=handoff) 新开一篇，**append-only、不追改旧账本**；③**项目笔记 MEMORY.md = 可复用的结论/决策**。维护时机（**条件触发，不是每轮**）：**① 白板还是「自动建立 · 待模型重写」的骨架时（说明本工作区还没有真白板）——在理解项目全貌后先把它重写成真内容**；② 完成阶段性工作、或发现白板/账本所述与现状不符、或方向有实质变化时——**写记忆的同时顺手维护白板**，不要新开一轮专程去做。（骨架由宿主自动落，但那只是占位；**不要停在骨架**。）**禁止**：未得用户同意不得删减白板既有内容（只报告过时，不自动删）；白板/产物功能关闭时跳过白板维护、不要因此报错。'
 
 /** Route family. */
 export const API = {
@@ -170,6 +226,7 @@ export const API = {
   browseDir: '/api/dsh-auto-memory/browse-dir',
   pickDir: '/api/dsh-auto-memory/pick-dir',
   updateCheck: '/api/dsh-auto-memory/update-check',
+  recallStats: '/api/dsh-auto-memory/recall-stats',
   update: '/api/dsh-auto-memory/update',
   config: '/api/dsh-auto-memory/config',
   reflect: '/api/dsh-auto-memory/reflect',
@@ -209,6 +266,9 @@ export const API = {
   'memory-hub': '/api/dsh-auto-memory/memory-hub',
   'storage-manage': '/api/dsh-auto-memory/storage-manage',
   models: '/api/dsh-auto-memory/models',
+  'migrate-export': '/api/dsh-auto-memory/migrate-export',
+  'migrate-inspect': '/api/dsh-auto-memory/migrate-inspect',
+  'migrate-import': '/api/dsh-auto-memory/migrate-import',
 }
 
 /**
@@ -296,6 +356,12 @@ const DEFAULT_CONFIG = {
   /** Tier-0 目录最多占「注入预算」的比例（默认 **0.25**）：目录是索引层，不得把证据层（日志/笔记）挤空。
    *  与 `tier0MaxTokens` 取小生效；另在注入侧再封顶一次（见 renderMemoryDynamic 的 catalogCost）。 */
   tier0BudgetShare: 0.25,
+  /** ★P10（2026-09-22 用户拍板）：**注入分区开关**（对象：kind → boolean）。
+   *  **缺省 = 全开**（只有显式 false 才关）⇒ 出厂行为逐字节不变、可一键回退。
+   *  可关清单 = PROMPT_SECTION_KEYS_V1；关掉某段即该段不再进入本轮注入。
+   *  设计取向（用户原话：不是为了优化，是让看不惯的用户能自己关）：**这是用户主权开关，
+   *  不是性能门** —— 因此不做任何"自动判断该不该关"的启发式。 */
+  promptSectionToggles: {},
   /** 群反馈第 4 条 / P0-④d：**注入来源排除**（坏记忆不再反复灌入）。
    *  字符串数组，四种写法（写死口径，可测；只做精确/前缀匹配，不做模糊猜测）：
    *    · 记忆 id：`mem_<32hex>`            → 排除该条命中
@@ -542,7 +608,19 @@ const DEFAULT_CONFIG = {
   pythonBackendEnabled: false,
   /** 推理 trace 观察器(2026-08-26 裁定默认开:监听目标是模型思维链,闭源概括式 CoT 同样纳入)。 */
   reasoningObserverEnabled: true,
-  /** Procedure 自动晋升。 */
+  /** ★ B-2 修复(2026-09-22)：**技能注入/唤起总闸**，语义纠正后的正确键（默认 **true**）。
+   *  取证：旧键 `procedurePromotionEnabled` 名字叫「技能固化与晋升」，但它的两个消费者
+   *  都与"晋升"无关 —— context-host.js:537（技能是否**注入上下文**）、
+   *  activation-host.js:330（**主动唤起**这条臂开不开）；真正的晋升由 store 门限 +
+   *  路由动作决定。旧键默认 false ⇒ 新用户装完"技能永不生效"且无任何提示。
+   *  ⚠️ 解析口径统一走 `lib/procedure-switch.js` 的 `resolveProcedureInjectEnabledPre`，
+   *  不得在本文件或其它文件里各自 inline 判断（否则又是一次口径漂移）。 */
+  procedureInjectEnabled: true,
+  /** 已弃用：语义错配的旧键，保留为**兼容别名**。
+   *  新键缺省时按本键取值（老用户显式关掉的不翻面）；两键都缺省才取 true。
+   *  设置页已改为操作新键，本键仅作读取回退，不再新增写入入口。
+   *  注：**不新增 `procedureAutoPromoteEnabled`** —— 全仓无任何自动晋升代码路径
+   *  （`applyAutomaticTransitions` 只导出零调用，见 BUGLIST P2-4），建了就是死配置。 */
   procedurePromotionEnabled: false,
   /** ★T10（2026-09-20）：**机械 procedure 切片**开关。
    *  背景（用户 2026-09-20 报「白板/审批里的技能名与内容看不懂」）：
@@ -563,6 +641,12 @@ const DEFAULT_CONFIG = {
   episodicMinSegments: 2,
   /** episodic: 保留的最多 episode 数(超出按时间淘汰)。默认 256。 */
   episodicRetention: 256,
+  /** ★#110（2026-09-22，用户拍板 1000）：facts 保留上限。超出按「撤销优先 → 最旧优先」淘汰，
+   *  重要项(pinned / user-memory / explicit / confidence≥0.8)最后才删。<=0 表示不限。 */
+  factRetentionMax: 1000,
+  /** ★#102（2026-09-22）：工作区发现上限。旧的硬编码 30 会把第 31 个起的工作区**静默丢弃**
+   *  （跨区检索/注入索引/总览一起少项）。现按「最近会话 mtime」降序截断，默认 200。 */
+  workspaceDiscoverMax: 200,
   /** procedure: 晋升所需跨会话多样性(≥N 个独立 session)。默认 3(M-04 元代码)。 */
   procedureMinSessions: 3,
   /** procedure: 晋升所需成功次数(≥N)。默认 2(一次成功不足以证明可靠)。 */
@@ -606,7 +690,7 @@ const DEFAULT_PROMPT_LAYERS = Object.freeze({
   snapshotReflectionTitle: '最近反思 {date}(前一天工作精华)',
   snapshotUserTitle: '用户级记忆 ~/.dsh/memory/MEMORY.md — 跨项目,必须遵守',
   snapshotNotesTitle: '项目长期笔记',
-  snapshotPlanTitle: '[白板 PLAN.md — 项目全貌快照(模型维护,用户在面板可见);内容过时/理解有实质变化时,用 memory_note(kind=plan) 重写]',
+  snapshotPlanTitle: '[白板 PLAN.md — 项目全貌快照(模型维护,用户在面板可见);**还是上面那种自动骨架、或内容已过时、或理解有实质变化时,用 memory_note(kind=plan) 重写**(重写=整体覆盖,旧版自动归档)]',
   snapshotHandoffTitle: '[最近交接 — 四段式账本(任务状态/目标/已试方案与失败原因/进度与下一步)]',
   snapshotWaterTitle: '[上下文水位提示 — 接近窗口上限]',
   snapshotWaterBody: '上下文水位约 {pct}%(官方公式估算:4 字符≈1 token)。窗口将满,按序执行:①memory_note(kind=handoff) 写交接账本——四段各 ≤5 行:任务状态(一句话+当前产物路径)、目标(可验证的完成标准)、已试方案与失败原因(写成「方案→失败原因」,保留关键报错词)、进度与下一步(可直接执行的第一步,带文件或命令);②memory_note(kind=plan) 刷新白板全貌;③在回复正文明确建议用户开新窗口续接。可分解的子任务优先派子代理隔离上下文。不要跳过账本直接继续对话。',
@@ -629,7 +713,7 @@ const DEFAULT_PROMPT_LAYERS = Object.freeze({
     + '【收尾自检】本轮有实质产出才做；纯只读/闲聊轮跳过。三个方向 + 分类别丢：\n'
     + '① 写记忆文件 memory_log —— kind 按性质选，**不要一律 fact**：rule=用户约束/约定（会被规则层当硬约束注入）、preference=偏好、fact=事实记录、todo=待办；\n'
     + '② 更新白板与账本 —— ★**硬映射(满足即必须做,别自行判断"算不算"变化)**:\n   · 本轮**改过 lib/ 下任何文件**(含测试/工具) ⇒ 必写 **memory_note(kind=handoff)** 四段式账本;\n   · 白板"当前进度"与本轮结束时的**事实不符**(回归数字/已完成项/下一步) ⇒ 必做 **memory_note(kind=plan)** 重写白板;\n   · 仅补充一条可复用结论 ⇒ 才用 **memory_note(kind=note, action=append)**。\n   ⚠️ **kind=note 不等于白板/账本**——只写 note 却宣称"已更新白板与账本"是**失职**;write 直接写 docs/ 的 md 也**不算**插件记忆。\n'
-    + '③ 长期记忆判断（三个去处）—— 跨会话有用的 → memory_note / 跨项目规则 → memory_user / **跑通且可复用的多步流程 → memory_procedure**（技能库唯一模型入口，不写就没有；建议填 successCriteria）；\n'
+    + '③ 长期记忆判断（三个去处）—— 跨会话有用的 → memory_note / 跨项目规则 → memory_user / **规则条目增删改（用户级硬约束，含过时条目真删）→ memory_rules** / **跑通且可复用的多步流程 → memory_procedure**（技能库唯一模型入口，不写就没有；建议填 successCriteria）；\n'
     + '④ 结论失效/被取代 —— 传 `supersedes=` 旧条目 mem_id 标 **superseded（被更新结论取代）**；**当时就做错了要撤回**则传 `retract=` 标 **retracted（撤回）**并尽量附 `retractReason=` 说明错在哪（两者不同：前者有后继，后者本身就是教训）；标错了用 `restore=` 撤回；\n'
     + '⑤ 看板落列 —— 白板/账本内容要进面板看板泳道，须在标题或正文写 tag：`type:goal` / `type:state` / `type:dead-end` / `type:progress`（5 条泳道含「版本归档」，靠归档动作而非 tag）；不写 tag 系统只能按标题文字猜，常落空；\n'
     + '⑥ 语体 —— 客观陈述、第三人称，只留可复用的事实/决策/规则/路径（不写"我考虑/我排查/我想"）。',
@@ -646,6 +730,40 @@ const DEFAULT_PROMPT_LAYERS = Object.freeze({
   staticWriteDiscipline: '[记忆写入纪律 — 必须遵守]',
 })
 
+/**
+ * ★P10：**可关的注入分区**（设置页开关据此枚举）。
+ *
+ * 判据：①该段是"内容/行为"而非"框架包裹"；②关掉它不会破坏注入块结构。
+ * **刻意排除**（不暴露开关）：`frame-head` / `frame-meta` / `frame-inscription` / `frame-tail`
+ *   —— 它们是 `<memory_system>` 的开合与状态行，关掉会产出没有闭合标签的块。
+ * 值与 `renderMemoryDynamic` 里 `pushPart(bucket, kind, …)` 的 kind 逐字对应（守卫锁一致性）。
+ */
+export const PROMPT_SECTION_KEYS_V1 = Object.freeze([
+  'rules-section',      // 规则段（用户级硬约束；关掉=不再注入「必须遵守」层）
+  'tier0-catalog',      // Tier-0 常驻目录（指引层）
+  'whiteboard-plan',    // 白板 PLAN 快照
+  'handoff-ledger',     // 交接账本
+  'calendar',           // 日历与日程
+  'external-memory',    // 其他 AI 工具记忆
+  'external-sessions',  // 历史会话索引
+  'workspace-map',      // 其他工作区记忆索引
+  'welcome-title',      // 新工作区欢迎语（标题）
+  'welcome-body',       // 新工作区欢迎语（正文）
+  'plan-update-request',// 白板更新请求（must；关掉=模型不再被要求更新白板）
+  'water-advisory',     // 上下文水位提醒（must；关掉=不再提醒收尾写账本）
+  'handoff-pointer',    // 未绑定工作区时的账本指针
+])
+
+/**
+ * ★P10-T2（2026-09-22）：上面 13 段里**带硬性行为要求**的子集 —— 设置页二级页据此在开关旁
+ * 标注「关掉会发生什么」（普通段落只需通用提示）。
+ * 纪律：本集合**必须是 PROMPT_SECTION_KEYS_V1 的子集**（守卫断言），不得独立增删语义。
+ */
+export const PROMPT_SECTION_MUST_V1 = Object.freeze([
+  'plan-update-request', // 关掉 = 模型不再被要求更新白板
+  'water-advisory',      // 关掉 = 不再提醒收尾写账本
+])
+
 export { DEFAULT_PROMPT_LAYERS }
 
 // ---------- 小工具 ----------
@@ -903,13 +1021,44 @@ function hasParentSession(x) {
   } catch (e) { return false }
 }
 
-/** 诊断输出:写 ~/.dsh/dsh-auto-memory-diagnose.log(append)+console.log 双保险。验证完移除。 */
+/**
+ * 诊断日志路径（单一来源）。★2026-09-22（用户拍板）：路径只在这里拼一次，
+ * diag() 落盘、轮转、debugInfo().logs 三处共用，避免三份拼法各自漂移。
+ */
+function diagLogFile() {
+  return path.join(dshHome(), 'dsh-auto-memory-diagnose.log')
+}
+
+/**
+ * 诊断日志轮转（★2026-09-22 用户拍板「记录太多了」）。
+ * 触发：单文件 > DIAG_MAX_BYTES。动作：改名为 `.1`（覆盖上一份 .1）后重新开始写。
+ * 只保留当前 + 1 份历史（最多 2 个文件），**不是无限增长**——实测未轮转时已达 11 MB / 11 万行。
+ * 全程 try/catch：轮转失败绝不影响落盘本身（fail-soft，与既有 _diagChain 同纪律）。
+ */
+const DIAG_MAX_BYTES = 2 * 1024 * 1024
+function rotateDiagLogIfNeeded() {
+  try {
+    const f = diagLogFile()
+    if (!existsSync(f)) return false
+    if (statSync(f).size <= DIAG_MAX_BYTES) return false
+    const bak = f + '.1'
+    try { if (existsSync(bak)) rmSync(bak, { force: true }) } catch (e) {}
+    renameSync(f, bak)
+    return true
+  } catch (e) { return false }
+}
+
+/** 诊断输出:写 diagLogFile()(append，超限自动轮转)。★2026-09-22 起**不再** console.log。 */
 let _diagChain = Promise.resolve()
+let _diagRotated = false
 function diag(msg) {
   try {
     const line = new Date().toISOString() + ' ' + msg + '\n'
-    _diagChain = _diagChain.then(() => appendFile(path.join(dshHome(), 'dsh-auto-memory-diagnose.log'), line, 'utf8')).catch(() => {})
-    console.log('[dsh-auto-memory] ' + msg)
+    // ★2026-09-22（用户拍板）：**不再向控制台输出**。诊断行只落盘，PowerShell 保持干净。
+    //   根治的是"循环刷屏"：本函数是唯一每轮/每次动作都会调用的日志出口（旧实现写盘后又打一遍控制台）。
+    //   要看他：面板「诊断」页签（走 debugInfo().logs），或直接打开 diagLogFile() 指的路径。
+    if (!_diagRotated) { _diagRotated = rotateDiagLogIfNeeded() }
+    _diagChain = _diagChain.then(() => appendFile(diagLogFile(), line, 'utf8')).catch(() => {})
   } catch (e) {}
 }
 
@@ -1608,7 +1757,9 @@ class MemoryEngine {
 
   /** callId→rootCallId 关联账本(root/nested tool call;tools/result 与持久 tool/result 双通道合并,有界)。关闭模式零留存。 */
   linkObserverCall(runtime, callId, rootCallId, name, via) {
-    if (!runtime || !callId) return
+    // ★#117 P3-1②（2026-09-22）：与同文件 ingestEnvelope 的 disposed 闸对齐 ——
+    //   旧实现漏了这一处 ⇒ dispose 之后 linkObserverCall 仍会惰性重建 callLinks（挂在已 disposed runtime 上）。
+    if (!runtime || runtime.disposed || !callId) return
     if (this.config.associativeMemoryEnabled !== true) return // 方案 B:关闭时不保留任何关联数据
     if (!runtime.callLinks) runtime.callLinks = new Map()
     const key = String(callId)
@@ -2318,6 +2469,73 @@ class MemoryEngine {
   /** 白板重写:旧 PLAN.md 有实质内容且与新内容不同时,先归档到 handoff/archive/PLAN-<ts>.md 再写新快照(保留更改历史)。
    *  P7(2026-09-09)白板老化:新内容中标题命中 /历史|踩坑|流水线要点/ 的顶层「## 」节移入 handoff/archive/PLAN-history-<ts>.md
    *  (同秒多写 -b/-c 后缀防撞),PLAN.md 只留当前状态;内容只移动不删除;无匹配节 → 行为与旧版完全一致。 */
+  /**
+   * ★2026-09-22（用户拍板）：**新工作区自动首建白板骨架** —— 白板首建缺口的正解。
+   *
+   * 缺口（证据见 docs/internal/TODO-NEXT-20260922.md §C.4）：写盘链路完整（含首建、有用例且绿），
+   *   但四处指令**只描述「重写」**（见本批 ③④⑤⑥）⇒ 没有 PLAN.md 的工作区里触发条件结构性恒假；
+   *   且注入侧 planText||latestHandoffText 为假时整段白板提示不注入，模型连暗示都收不到。
+   *
+   * 修法：宿主不再等模型 —— 工作区第一次有会话活动就把骨架落下来。骨架一存在：
+   *   ① 注入条件转真 ⇒ 白板快照每轮注入 ⇒ 既有「维护/重写」纪律自举生效；
+   *   ② 面板不再显示空态 ⇒ 前端承诺与后端事实一致；
+   *   ③ kind=plan 的「重写」语义有了对象，不再空转。
+   *
+   * 纪律：
+   *   - **只写一次**：PLAN.md 已存在且非空即跳过（模型重写过的白板绝不被骨架覆盖）。
+   *   - **只走唯一写盘口**：委托 writePlanSnapshot ⇒ 归档/锚点/sidecar/事件日志/写入门全复用。
+   *   - **产物层闸门**：只判 handoffEnabled（白板是产物层），**不判** boardMode 与 autoContinueEnabled
+   *     —— 后者管的是"要不要接续材料"，与"白板存不存在"无关（功能开关解耦纪律）。
+   *   - **fail-soft**：任何失败只回 {ok:false}，绝不影响轮次收尾。
+   *   - 骨架必须过 P-H1 判据（≥1 个 body ≥20 非空白字符的 '## ' 顶节），否则"首建"落不下去。
+   */
+  async ensurePlanBoardPre(projectDir) {
+    try {
+      if (!projectDir) return { ok: false, error: 'no-project-dir' }
+      if (this.config && this.config.handoffEnabled === false) return { ok: true, skipped: 'handoff-disabled' }
+      const planPath = path.join(projectDir, 'handoff', 'PLAN.md')
+      const existing = await this.readTextSafe(planPath)
+      if (existing && existing.trim()) return { ok: true, skipped: 'exists' }
+      const r = await this.writePlanSnapshot(projectDir, this.skeletonPlanTextPre())
+      if (!r || !r.ok) return { ok: false, error: (r && r.error) || 'seed-write-failed', gate: r && r.gate }
+      return { ok: true, seeded: true, path: planPath, at: Date.now() }
+    } catch (e) {
+      return { ok: false, error: String((e && e.message) || e) }
+    }
+  }
+
+  /** 白板骨架正文（纯字符串，零 IO）。必须过 P-H1 判据；刻意不写任何假内容。 */
+  skeletonPlanTextPre() {
+    const NL = String.fromCharCode(10)
+    return [
+      '# 项目全貌（自动建立 · 待模型重写）',
+      '',
+      '## 这是什么',
+      'type:state',
+      '本白板由 dsh-auto-memory 在本工作区首次活动时**自动建立**，内容尚未填写。',
+      '模型在理解本项目全貌后，请用 memory_note(kind=plan) 整体重写本页，写入真实的全貌。',
+      '',
+      '## 进度与下一步',
+      'type:progress',
+      '本工作区暂无阶段性结论。完成首轮实质工作后请重写白板，写明当前状态与下一步（可直接执行的第一步）。',
+      '',
+    ].join(NL)
+  }
+
+  /** 轮末兜底：为当前 agent 的工作区自动首建白板（异步、fail-soft、不阻塞收尾）。 */
+  async ensurePlanBoardForAgentPre(agent) {
+    try {
+      if (!this.configLoaded) { try { await this.loadConfig() } catch (_) {} }
+      if (this.config && this.config.handoffEnabled === false) return { ok: true, skipped: 'handoff-disabled' }
+      const p = await this.resolvePaths(agent)
+      const projectDir = (p && p.projectDir) || (p && p.handoffDir ? path.dirname(p.handoffDir) : '')
+      if (!projectDir) return { ok: false, error: 'no-project-dir' }
+      return await this.ensurePlanBoardPre(projectDir)
+    } catch (e) {
+      return { ok: false, error: String((e && e.message) || e) }
+    }
+  }
+
   async writePlanSnapshot(projectDir, content, opts) {
     const dir = path.join(projectDir, 'handoff')
     const planPath = path.join(dir, 'PLAN.md')
@@ -2499,7 +2717,18 @@ class MemoryEngine {
     // 保留调用方刚写入的富条目(rebuild 只是补倒排, 正文预览以已有条目为准)
     fresh.entries = entries
     await mkdir(sideDir, { recursive: true })
-    await writeFile(path.join(sideDir, 'index.json'), JSON.stringify(fresh, null, 2), 'utf8')
+    // ★2026-09-22：改**原子写**（tmp + 有界重试 rename）。
+    //   旧实现是裸 `await writeFile(index.json, …)` —— 这份索引 235 KB，写入过程**不是原子的**：
+    //   面板/工具恰在此时读，读到的要么是零字节、要么是半截 JSON ⇒ `JSON.parse` 失败 ⇒ 看板/白板
+    //   **整块空白**，写完才恢复（用户实测：「白板不见了 → 过了一会儿又出现了」）。时间戳可对：
+    //   索引在 09-22 00:52:10 被整份重写，同一秒宿主诊断 `…-diagnose.log` 连出 6 条
+    //   `ctx-host degrade: index-not-ready(commit)` —— 就是这段「不可读窗口」。
+    //   rename 在同目录内是原子替换；Windows 上读侧句柄争用会抛 EPERM/EBUSY，
+    //   故复用 #48 的 `retryRename`（有界退避，且不做 unlink/copy 回退以免破坏原子性）。
+    const idxPath = path.join(sideDir, 'index.json')
+    const tmpPath = idxPath + '.tmp'
+    await writeFile(tmpPath, JSON.stringify(fresh, null, 2), 'utf8')
+    await retryRename(tmpPath, idxPath)
     return fresh
   }
 
@@ -2522,7 +2751,17 @@ class MemoryEngine {
     const sideDir = path.join(projectDir, 'handoff')
     const docs = await this._collectWhiteboardDocsPre(projectDir).catch(() => [])
     const index = rebuildSidecarIndexPre(this.wbWsKeyPre(projectDir), docs)
-    try { await mkdir(sideDir, { recursive: true }); await writeFile(path.join(sideDir, 'index.json'), JSON.stringify(index, null, 2), 'utf8') } catch (_) {}
+    try {
+      await mkdir(sideDir, { recursive: true })
+      // ★2026-09-22：与 `_writeSidecarIndexPre` 同一口径 —— **重建路径也必须原子替换**。
+      //   这里同样是整份索引（实测 235 KB）裸写；而重建恰恰是在「索引缺失/损坏」时被触发的，
+      //   此刻面板正等着读这份文件 ⇒ 裸写期间的读者拿到半截 JSON，白板依旧整块空白。
+      //   （本处由守卫 `smoke-test-board-index-atomic-pre.mjs` 抓出：它断言「全仓不得再有裸写 index.json」。）
+      const rIdx = path.join(sideDir, 'index.json')
+      const rTmp = rIdx + '.tmp'
+      await writeFile(rTmp, JSON.stringify(index, null, 2), 'utf8')
+      await retryRename(rTmp, rIdx)
+    } catch (_) {}
     return index
   }
 
@@ -5558,7 +5797,7 @@ class MemoryEngine {
     // 旧行为的病（两条独立病因，都有代码行号）：
     //   A. 措辞：开场白把"规矩"与"资料"统一降格为「只是背景事实与规则参考」⇒ 规则不醒目；
     //   B. 节奏：`snapshotMinGapRounds` 使规矩在第 2–5 轮**不在场**（模型不是不听话，是没收到）。
-    // 开关 `rulesLayeringMode`（**默认 'off'**）= 新旧并存 + 一键回退：关掉即完全回到旧行为。
+    // 开关 `rulesLayeringMode`（**出厂默认 'self'**，见 DEFAULT_CONFIG；旧注释写成 'off' 是错的）= 新旧并存 + 一键回退：关掉即完全回到旧行为。
     // 开启后规则段走分项账本的 `rules` 分项：**不受 gap 约束、不参与裁剪**（v2 §3.3 选 (ii)）。
     let rulesLayer = { enabled: false, text: '', rules: [] }
     let rulesSection = { text: '', chars: 0 }
@@ -5592,7 +5831,13 @@ class MemoryEngine {
     // ★2026-09-15 修复：每段带 `priority`（low / normal / must）。超额时**先丢 low，must 永不丢**。
     // 旧实现是**纯位置式**丢弃（从分项尾部丢），尾部恰好是 user-memory / project-notes
     // ⇒ 价值最高的两段先死（本机实测）。位置顺序是渲染顺序，不是价值顺序。
+    // ★P10：**注入分区开关**的唯一闸门（每段都过这里）。缺省全开 ⇒ 只有显式 false 才拦。
+    //   只影响本段自己，不触发任何其他功能变化（用户铁律：单一开关不得顺带改变别的行为）。
+    const secToggles = (cfg && cfg.promptSectionToggles && typeof cfg.promptSectionToggles === 'object')
+      ? cfg.promptSectionToggles : {}
+    const sectionsOff = []
     const pushPart = (bucket, kind, text, priority) => {
+      if (secToggles[kind] === false) { sectionsOff.push(kind); return }
       if (text === undefined || text === null || text === '') return
       segs.push({ bucket, kind, text, priority: priority || 'normal' })
     }
@@ -5732,6 +5977,22 @@ class MemoryEngine {
       // 只用于账本的「合计是否超预算」可见性（落 meta；诊断类降级不进注入文本，避免每轮噪声）
       budgetChars,
     })
+    // ★③ 召回统计 · inject 通道（2026-09-22 用户拍板「分开计算」）：记**这一轮实际注入了哪些段、各多少字符**。
+    //   为什么与 model 通道分开：inject = 「系统一直塞给我」= **成本**；model = 「我明确想找」= 高信号。
+    //   合成一个数会把「模型懒得检索」误读成「这条不重要」，而这个误读会被写进加权公式、越滚越偏。
+    //   数据源用 `envelope`（不是 `segs`）：它已过预算裁剪 ⇒ 记的是**真正进 prompt 的段**，不是想注入的段。
+    //   ★只读：本块不修改 envelope、不影响注入文本（守卫断言：注入文本逐字节不变）。
+    try {
+      if (this._recallStats && envelope && Array.isArray(envelope.segments)) {
+        const segList = envelope.segments.map((sg) => ({
+          name: sg.kind, chars: (sg.text || '').length, layer: sg.bucket,
+        }))
+        const droppedList = (envelope.dropped || []).map((x) => ({
+          name: x.kind + '(dropped)', chars: 0, layer: x.bucket,
+        }))
+        this._recallStats.observeInjection(segList.concat(droppedList))
+      }
+    } catch (_) {}
     // T0-3：账本挂 state，面板/排障/后续 P6A 都读它（**不再有第二本账**）
     try {
       this.state.envelopeMeta = {
@@ -5769,7 +6030,7 @@ class MemoryEngine {
     lines.push('- 新工作区(无历史日志/笔记):主动用 memory_recall 探索本机历史,判断该项目是否曾在其他 AI 工具中工作过;也可调用 memory_external 查看并接入外部记忆;检索时在正文中说明"我先查一下之前的记录"。')
     lines.push('- 完成实质性工作后立即调用 memory_log 追加今日日志(append-only,绝不覆盖):建/改应用、修 bug、写文档、重构、技术选型、用户约定或偏好。')
     lines.push('- progress 与 memory 一起写:写日志的同时,把有跨会话长期价值的内容一并写入记忆——跨项目规则 → memory_user,仅本项目 → memory_note;两者在同一轮完成,互不冲突、不遗漏。')
-    lines.push('- **交接与白板(长任务续命)**:阶段产出或方向变化时,调用 memory_note(kind=handoff) 写四段式交接账本——任务状态/目标/已试方案与失败原因/进度与下一步,给下一个上下文窗口续命;对项目全貌的理解发生实质变化时,用 memory_note(kind=plan) 重写白板 PLAN.md(人能读的项目规划图,旧版自动归档,用户在面板实时可见)。账本质量纪律:每段 ≤5 行;失败项写成「方案→失败原因」并保留关键报错词;下一步必须是可直接执行的第一步(带文件路径或命令);不写临时信息。两者会注入到你的动态快照首位,是跨窗口交接的凭据。')
+    lines.push('- **交接与白板(长任务续命)**:阶段产出或方向变化时,调用 memory_note(kind=handoff) 写四段式交接账本——任务状态/目标/已试方案与失败原因/进度与下一步,给下一个上下文窗口续命;白板 PLAN.md(人能读的项目规划图,用户在面板实时可见)：**新工作区的骨架由宿主自动落(标题带「自动建立 · 待模型重写」),那只是占位——你理解项目全貌后要用 memory_note(kind=plan) 把它重写成真内容**;此后对项目全貌的理解发生实质变化时同样重写(整体覆盖,旧版自动归档)。账本质量纪律:每段 ≤5 行;失败项写成「方案→失败原因」并保留关键报错词;下一步必须是可直接执行的第一步(带文件路径或命令);不写临时信息。两者会注入到你的动态快照首位,是跨窗口交接的凭据。')
     lines.push('- 只记录有跨会话长期价值的;不记临时信息(搜索结果、临时路径、工具报错)。')
     // ★T6（2026-09-20 用户拍板）：**看板分列机制** —— 模型此前完全不知道有 tag 这回事。
     //   根因：wb-sidecar.js:594-597 的 WB_KANBAN_LANES_V1 靠 matchTags 匹配
@@ -6215,7 +6476,7 @@ class MemoryEngine {
         if (rank && rank.scores && rank.scores.size) semScores = rank.scores
       } catch (eBest) {
         // R3：预期外失败 —— 引擎/worker 抛错导致回退词法，用户应当能知道（不只是 diag 一行）。
-        try { diag('recall 语义臂择优降级: ' + String((eBest && eBest.message) || eBest).slice(0, 120)) } catch (_) {}
+        try { diagThrottled('recall-best', 'recall 语义臂择优降级: ' + String((eBest && eBest.message) || eBest).slice(0, 120)) } catch (_) {}
         try { if (this._degradeSink) this._degradeSink.record('semantic-arm', String((eBest && eBest.message) || eBest).slice(0, 160)) } catch (_) {}
       }
       if (semScores && semScores.size) {
@@ -6254,7 +6515,7 @@ class MemoryEngine {
       } catch (eImp) {
         // R3：预期外失败才记。目录不存在已被上面的 existsSync 守卫拦下（预期内分支，静默）；
         // 走到这里的都是真异常（聚合/读文件/import 失败）⇒ 应当留痕。
-        try { diag('evidence-agg 降级为中性(impMap 空): ' + String((eImp && eImp.message) || eImp).slice(0, 140)) } catch (_) {}
+        try { diagThrottled('evidence-agg', 'evidence-agg 降级为中性(impMap 空): ' + String((eImp && eImp.message) || eImp).slice(0, 140)) } catch (_) {}
         try { if (this._degradeSink) this._degradeSink.record('evidence-arm', String((eImp && eImp.message) || eImp).slice(0, 160)) } catch (_) {}
       }
       const l0Hits = l0Corpus.filter((c) => c.lex > 0 || (typeof c.sem === 'number' && c.sem >= 0.5))
@@ -6267,7 +6528,7 @@ class MemoryEngine {
         const tp = await import('./temporal-parse.js')
         tr = tp.parseTemporalQueryPre(query, { now: Date.now() })
         dateMsOf = tp.labelToDateMsPre
-      } catch (eTr) { try { diag('temporal-parse 降级(无时间臂): ' + String((eTr && eTr.message) || eTr).slice(0, 140)) } catch (_) {} }
+      } catch (eTr) { try { diagThrottled('temporal-parse', 'temporal-parse 降级(无时间臂): ' + String((eTr && eTr.message) || eTr).slice(0, 140)) } catch (_) {} }
       const tempFieldOf = (c) => {
         if (!tr || typeof dateMsOf !== 'function') return undefined
         const d = dateMsOf(c.label)
@@ -6303,7 +6564,17 @@ class MemoryEngine {
           .sort((a, b) => b.lex - a.lex || (b.sem || 0) - (a.sem || 0) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
           .slice(0, Math.max(1, Number(limit) || 8))
       }
-      if (l0Top.length) {
+        // ③ 召回统计埋点（2026-09-22）：**只读** l0Top 做计数，绝不改其顺序/内容。
+      //   为什么放这里：l0Top 已定型（融合或降级排序完成）、尚未被转成输出文本
+      //   ⇒ 记的就是"本轮真实交付的命中集"，含 finalRank 口径。fail-soft 包住，统计绝不干扰召回。
+      try {
+        if (this._recallStats) {
+          this._recallStats.observe(l0Top.map((c) => ({
+            id: c.id, layer: c.layer, score: typeof c.sem === 'number' ? c.sem : c.lex, reason: c.reason,
+          })), { channel: 'model' })
+        }
+      } catch (_) {}
+    if (l0Top.length) {
         out.push('== L0 命中(摘要,含 id/得分/匹配原因;展开单条原文传 expand="mem_xxx") ==')
         // ★R4-B（2026-09-18）分层**呈现**：把已排好序的命中**按层分组**后展示。
         //   ★排序零改动：分组只重排"行"，不改 `l0Top` 的融合/词法序；组内保持原相对顺序，
@@ -6603,28 +6874,44 @@ class MemoryEngine {
 
   /** 扫描 ~/.dsh/sessions 下所有会话,提取去重后的工作区路径。 */
   async discoverWorkspaces() {
-    const out = new Map()
+    // ★#102（2026-09-22）：解除「硬编码 30 且静默截断」。
+    //   旧实现：`if (out.size >= 30) return` —— 上限写死、按**目录遍历顺序**取前 30，
+    //   第 31 个工作区起被**静默丢弃**（跨区检索 / 注入索引 / 工作区总览一起少项，且无任何信号）。
+    //   现在：① 上限走配置 `workspaceDiscoverMax`（默认 200，非法值回落默认）；
+    //        ② 以「该工作区最近一次会话文件的 mtime」为活跃度，按新→旧排序后再截断 ——
+    //           即便真到上限，丢掉的也是**最久没用过**的，而不是碰巧排在后面的；
+    //        ③ 仅保留一个 5×上限的遍历安全阀，防止 sessions 目录异常膨胀时无限走盘。
+    const capRaw = Number(this.config && this.config.workspaceDiscoverMax)
+    const cap = (Number.isFinite(capRaw) && capRaw >= 1) ? Math.floor(capRaw) : 200
+    const walkLimit = cap * 5
+    const out = new Map() // cwd → 最近会话文件 mtimeMs
     const sessionsDir = path.join(dshHome(), 'sessions')
     const walk = async (dir, depth) => {
       if (depth > 4) return
       let entries
       try { entries = await readdir(dir, { withFileTypes: true }) } catch (e) { return }
       for (const en of entries) {
-        if (out.size >= 30) return
-        if (en.isDirectory()) await walk(path.join(dir, en.name), depth + 1)
-        else if (en.isFile() && (en.name.endsWith('.jsonl.zstd') || en.name.endsWith('.jsonl'))) {
-          try {
-            const first = await this.readFirstLine(path.join(dir, en.name))
-            if (first) {
-              const h = JSON.parse(first)
-              if (h && typeof h.cwd === 'string' && h.cwd) out.set(h.cwd, true)
-            }
-          } catch (e) {}
-        }
+        if (out.size >= walkLimit) return
+        if (en.isDirectory()) { await walk(path.join(dir, en.name), depth + 1); continue }
+        if (!en.isFile() || !(en.name.endsWith('.jsonl.zstd') || en.name.endsWith('.jsonl'))) continue
+        const full = path.join(dir, en.name)
+        try {
+          const first = await this.readFirstLine(full)
+          if (!first) continue
+          const h = JSON.parse(first)
+          if (!h || typeof h.cwd !== 'string' || !h.cwd) continue
+          let mt = 0
+          try { mt = (await stat(full)).mtimeMs } catch (e) {}
+          const prev = out.get(h.cwd) || 0
+          if (mt > prev) out.set(h.cwd, mt)
+        } catch (e) {}
       }
     }
     await walk(sessionsDir, 0)
-    return Array.from(out.keys())
+    return Array.from(out.entries())
+      .sort((a, b) => b[1] - a[1])       // 活跃度降序（mtime 新→旧）
+      .slice(0, cap)
+      .map((e) => e[0])
   }
 
   /** 读取某工作区的近期记忆(最近5天日志 + 项目笔记头部),无 .dsh-memory 返回 null。 */
@@ -6644,6 +6931,208 @@ class MemoryEngine {
     return { logs, notes: truncateHead(notes || '', 800) }
   }
 
+  // ───────────────────── 迁移搬包（migrate pack）─────────────────────
+  // 用户拍板：导出范围=主体（不带语义索引）；路径需重写；入口放存储管理；先做一次性搬包。
+  // ★IO 全在本节，纯逻辑全在 lib/migrate-pack.js（可单测、可守卫）。
+
+  /** 汇总文件路径（跨工作区全局）。 */
+_wsSummaryFile() { return path.join(dshHome(), 'memory', 'workspaces-summary.json') }
+
+  /** 当前工作区在 summary 里的那条记录（导出时随包带走）。 */
+  async _wsSummaryRecord(ws) {
+    try {
+      const raw = await this.readTextSafe(this._wsSummaryFile())
+      if (!raw) return null
+      const j = JSON.parse(raw)
+      const list = j && Array.isArray(j.workspaces) ? j.workspaces : []
+      return list.find((x) => x && x.path === ws) || null
+    } catch (_) { return null }
+  }
+
+  /** 目标工作区目录里现有文件（键=相对 slug 目录的路径）—— 供「预览差异」算新增/覆盖。
+   *  ★只读，且只读文本类文件（记忆数据全是文本）。 */
+  async _readExistingWorkspaceFiles(ws) {
+    const dir = this.projectDirOf(ws)
+    const out = {}
+    const walk = async (q, rel) => {
+      let ents = []
+      try { ents = await readdir(q, { withFileTypes: true }) } catch (_) { return }
+      for (const en of ents) {
+        const abs = path.join(q, en.name)
+        const r = rel ? rel + '/' + en.name : en.name
+        if (en.isDirectory()) { await walk(abs, r); continue }
+        try {
+          const st = await stat(abs)
+          if (!st.isFile() || st.size > 8 * 1024 * 1024) continue
+          out[r] = await readFile(abs, 'utf8')
+        } catch (_) {}
+      }
+    }
+    await walk(dir, '')
+    return out
+  }
+
+  /** 导出：打包一个工作区的全部记忆到一个 .dam-pack（单 JSON；compress=true 时 gzip）。 */
+  async migrateExport(opts) {
+    const o = opts || {}
+    const ws = String(o.ws || '')
+    if (!ws) return { ok: false, error: 'missing-ws' }
+    const outPath = String(o.outPath || '')
+    if (!outPath) return { ok: false, error: 'missing-out-path' }
+    const dir = this.projectDirOf(ws)
+    const st = await stat(dir).catch(() => null)
+    if (!st || !st.isDirectory()) return { ok: false, error: 'workspace-dir-missing' }
+    // ★只收文本类文件：记忆数据全部是 .md/.json/.jsonl/.txt；二进制跳过并记警告（不静默丢）
+    const TEXT_RE = /\.(md|json|jsonl|txt|markdown)$/i
+    const files = {}
+    const skipped = []
+    let bytes = 0
+    const walk = async (q, rel) => {
+      let ents = []
+      try { ents = await readdir(q, { withFileTypes: true }) } catch (_) { return }
+      for (const en of ents) {
+        const abs = path.join(q, en.name)
+        const r = rel ? rel + '/' + en.name : en.name
+        if (en.isDirectory()) { await walk(abs, r); continue }
+        if (!TEXT_RE.test(en.name)) { skipped.push(r); continue }
+        try {
+          const s = await stat(abs)
+          if (!s.isFile()) continue
+          if (s.size > 32 * 1024 * 1024) { skipped.push(r + '(too-large)'); continue }
+          const txt = await readFile(abs, 'utf8')
+          files[r] = txt
+          bytes += Buffer.byteLength(txt, 'utf8')
+        } catch (_) { skipped.push(r + '(unreadable)') }
+      }
+    }
+    await walk(dir, '')
+    const built = buildPackPre({
+      ws, files,
+      summaryRecord: await this._wsSummaryRecord(ws),
+      pluginVersion: (this.manifest && this.manifest.version) || '',
+      sourceHost: os.hostname(),
+    })
+    if (!built.ok) return { ok: false, error: built.error, skipped }
+    const json = JSON.stringify(built.pack)
+    const compress = o.compress !== false
+    let payload = json, ext = '.dam-pack'
+    if (compress) { payload = nodeZlib.gzipSync(Buffer.from(json, 'utf8')); ext = '.dam-pack.gz' }
+    let finalPath = outPath
+    if (!/\.dam-pack(\.gz)?$/i.test(finalPath)) finalPath = finalPath.replace(/[\\/]+$/, '') + path.sep + migrateSlugPre(ws) + ext
+    await mkdir(path.dirname(finalPath), { recursive: true })
+    const tmp = finalPath + '.tmp'
+    await writeFile(tmp, payload)
+    await rename(tmp, finalPath)   // 原子落盘：写一半的包不会被认为是完整的
+    return {
+      ok: true, path: finalPath, format: MIGRATE_PACK_FORMAT_PRE,
+      stats: { fileCount: built.pack.stats.fileCount, bytes: built.pack.stats.bytes, packedBytes: Buffer.byteLength(payload) },
+      checksum: built.pack.checksum.value, compress, skipped,
+      warnings: built.warnings,
+    }
+  }
+
+  /** 读包（自动识别 gzip：gzip 魔数 1f 8b）。★坏包在 validate 阶段即拒，不写任何文件。 */
+  async _readPack(packPath) {
+    const buf = await readFile(packPath).catch(() => null)
+    if (!buf || !buf.length) return { ok: false, errors: ['pack-unreadable'] }
+    let json = null
+    try {
+      json = (buf[0] === 0x1f && buf[1] === 0x8b)
+        ? nodeZlib.gunzipSync(buf).toString('utf8')
+        : buf.toString('utf8')
+    } catch (_) { return { ok: false, errors: ['pack-corrupt'] } }
+    let pack = null
+    try { pack = JSON.parse(json) } catch (_) { return { ok: false, errors: ['pack-not-json'] } }
+    const v = validatePackPre(pack)
+    if (!v.ok) return { ok: false, errors: v.errors, warnings: v.warnings }
+    return { ok: true, pack, warnings: v.warnings }
+  }
+
+  /** 预览：算出「导入将要发生什么」。★这是**唯一**能算差异的地方；import 会重算同一份计划。 */
+  async migrateInspect(opts) {
+    const o = opts || {}
+    const r = await this._readPack(String(o.packPath || ''))
+    if (!r.ok) return { ok: false, errors: r.errors }
+    const targetWs = String(o.targetWs || r.pack.source.ws)
+    let existing = {}
+    try { existing = await this._readExistingWorkspaceFiles(targetWs) } catch (_) {}
+    const plan = planImportPre(r.pack, { targetWs, existingFiles: existing, onConflict: o.onConflict, rewriteBody: o.rewriteBody })
+    const { writeFiles, ...wire } = plan
+    return {
+      ok: true,
+      pack: {
+        format: r.pack.format, createdAt: r.pack.createdAt,
+        source: r.pack.source, runtime: r.pack.runtime,
+        stats: r.pack.stats, checksum: r.pack.checksum,
+      },
+      plan: wire,
+      sourceMissing: !(await stat(this.projectDirOf(r.pack.source.ws)).catch(() => null)),
+      warnings: r.warnings,
+    }
+  }
+
+  /** 导入：执行。★顺序 = 重算计划 → 备份 → 落盘 → 合并 summary（任一步失败即中止并回报）。 */
+  async migrateImport(opts) {
+    const o = opts || {}
+    const r = await this._readPack(String(o.packPath || ''))
+    if (!r.ok) return { ok: false, error: 'pack-invalid', errors: r.errors }
+    const targetWs = String(o.targetWs || r.pack.source.ws)
+    if (!targetWs) return { ok: false, error: 'missing-target-ws' }
+    const targetDir = this.projectDirOf(targetWs)
+    let existing = {}
+    try { existing = await this._readExistingWorkspaceFiles(targetWs) } catch (_) {}
+    // ★重算（而非信任前端传来的 plan）：防「预览与执行之间目标被改动」的 TOCTOU
+    const plan = planImportPre(r.pack, { targetWs, existingFiles: existing, onConflict: o.onConflict, rewriteBody: o.rewriteBody })
+    /** @type {{path:string, bytes:number, action:string}[]} */
+    const written = []
+    // S1：目标目录存在且非空 ⇒ 先整体备份（不可逆操作前的唯一保险）
+    let backup = null
+    const tst = await stat(targetDir).catch(() => null)
+    const hasExisting = Object.keys(existing).length > 0
+    if (tst && tst.isDirectory() && hasExisting) {
+      const stamp = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14)
+      backup = targetDir + '.bak-' + stamp
+      try { await this.copyDir(targetDir, backup) } catch (e) { return { ok: false, error: 'backup-failed', detail: String(e && e.message || e) } }
+    }
+    try {
+      await mkdir(targetDir, { recursive: true })
+      for (const [rel, text] of Object.entries(plan.writeFiles)) {
+        const abs = path.join(targetDir, rel)
+        await mkdir(path.dirname(abs), { recursive: true })
+        const tmp = abs + '.dam-tmp'
+        await writeFile(tmp, text, 'utf8')
+        await rename(tmp, abs)
+        written.push({ path: rel, bytes: Buffer.byteLength(text, 'utf8'), action: 'write' })
+      }
+    } catch (e) {
+      return { ok: false, error: 'write-failed', detail: String(e && e.message || e), backup, written }
+    }
+    // S4：summary 用 merge 不用 replace —— 目标机的其它工作区记录必须原样保留
+    let summaryAction = 'skipped'
+    let summaryError = null
+    try {
+      const cur = await this.readTextSafe(this._wsSummaryFile())
+      const merged = mergeSummaryRecordPre(cur ? JSON.parse(cur) : null, r.pack.summaryRecord, targetWs)
+      if (merged.changed) {
+        const f = this._wsSummaryFile()
+        const tmp = f + '.dam-tmp'
+        await writeFile(tmp, JSON.stringify(merged.summary, null, 2), 'utf8')
+        await rename(tmp, f)
+      }
+      summaryAction = merged.action
+    } catch (e) { summaryError = String(e && e.message || e) }
+    // 索引失效：语义索引按工作区缓存，路径/内容变了必须让它重建（S5：索引本身不随包走）
+    try { this._semanticIndexStaleByWorkspace = this._semanticIndexStaleByWorkspace || new Set(); this._semanticIndexStaleByWorkspace.add(targetWs) } catch (_) {}
+    try { if (this.state) this.state.loadedAt = 0; await this.refresh(undefined) } catch (_) {}
+    return {
+      ok: true, targetWs, targetSlug: migrateSlugPre(targetWs), backup,
+      pathChanged: plan.pathChanged, onConflict: plan.onConflict,
+      written: written.length, writtenFiles: written.slice(0, 200),
+      rewrite: { totalHits: plan.rewrite.totalHits, fileCount: plan.rewrite.fileCount, files: plan.rewrite.files.slice(0, 50) },
+      additions: plan.additions.length, overwrites: plan.overwrites.length,
+      summaryAction, summaryError,
+    }
+  }
   /** 工作区总览:每个工作区一个小总结 + 区内细分总结;结果缓存到用户级 ~/.dsh/memory/workspaces-summary.json(跨工作区全局)。 */
   async workspaceOverview(agent, force) {
     const cacheFile = path.join(dshHome(), 'memory', 'workspaces-summary.json')
@@ -6775,6 +7264,91 @@ class MemoryEngine {
     return Object.assign({}, snap, { verdict })
   }
 
+  // ---------- ★#110（2026-09-22）：hub 持久化 IO 健康度视图 ----------
+  /**
+   * 返回三层记忆（episodes/facts/procedures）落盘 IO 的健康度投影。
+   *
+   * **为什么需要**：hub 三店的 `io` 由 `hubIo()` 提供，旧实现 save/clear 内 `catch (_) {}`
+   * 把异常吞在这一层 ⇒ 上层三店（A-8 之后）的 `try { io.save() } catch` 永远不触发、
+   * 返回值恒为 `{ok:true, persisted:true}` ⇒ 「写不进去」在**任何**出口都不可见。
+   * 现在失败会照抛并同时记进 `_hubIoHealth`，本方法就是它的只读投影。
+   *
+   * 纪律：与 `_degradeViewSnapshot` / `_quotaViewSnapshot` 同款 —— 只出计数 + 人话原因 + 时间戳，
+   * **无路径、无原文**；任何异常都不得打断 debugInfo（全程 try/catch，失败返回空计数）。
+   */
+  _hubIoViewSnapshot() {
+    return hubIoHealthSnapshotPre(this._hubIoHealth)
+  }
+  /**
+   * 事实保留上限淘汰台账的只读投影（★P0-3 / 2026-09-22）。
+   *
+   * **为什么不能只用 stats**：`getStats()`（fact-store.js:824）返回的是累计计数，
+   * 而 `lastPrune` 是闭包变量、只经 `getLastPrune()`（:832）单独暴露 ⇒
+   * 「最近一次淘汰发生在什么时候、当时上限多少、超出多少」只有它能给。
+   *
+   * 纪律：与 `_hubIoViewSnapshot` / `_degradeViewSnapshot` 同款 —— 只出聚合数 + 时间戳，
+   * **无事实正文、无路径**；任何异常都不得打断 debugInfo（全程 try/catch，失败返回 null）。
+   * `protected > 0` 表示已轮到删「重要项」⇒ 上限设得过低，前端据此给告警色与指引。
+   */
+  /**
+   * ★2026-09-22（用户拍板）：诊断日志只读投影 —— 让「日志」在**界面里可查**，
+   * 不必再去翻 PowerShell 或手动找目录。与既有最小投影同一纪律：
+   * **只出计数/大小/时间戳/路径，不出日志正文**（正文可能含工作区内容）。
+   * 形状：{ path, dir, sizeBytes, sizeText, historyBytes, historyPath, lines, exists, rotatedNow }
+   * 消费点：lib/client.js 诊断页签（模块级渲染，不随刷新闪烁）。
+   */
+  _logsViewSnapshot() {
+    try {
+      const f = diagLogFile()
+      const bak = f + '.1'
+      let sizeBytes = 0
+      let exists = false
+      try { const st = statSync(f); sizeBytes = st.size; exists = true } catch (e) {}
+      let historyBytes = 0
+      try { historyBytes = statSync(bak).size } catch (e) {}
+      // 行数：只在文件不太大时数（避免每次开面板都全量扫 10MB+）
+      let lines = null
+      if (exists && sizeBytes <= DIAG_MAX_BYTES * 2) {
+        try {
+          const text = readFileSync(f, 'utf8')
+          lines = text.length ? text.replace(/\r\n$/, '').split(/\r?\n/).length : 0
+        } catch (e) {}
+      }
+      return {
+        path: f,
+        dir: path.dirname(f),
+        sizeBytes,
+        sizeText: fmtBytes(sizeBytes),
+        historyBytes,
+        historyPath: bak,
+        lines,
+        exists,
+        rotatedNow: _diagRotated,
+        note: '诊断日志（只读投影，不含正文）。崩溃/异常时请把这个路径下的文件附给维护者。',
+      }
+    } catch (e) { return { exists: false, error: String((e && e.message) || e) } }
+  }
+
+  _factsPruneViewSnapshot() {
+    try {
+      const st = this._factStore
+      if (!st) return null
+      const last = typeof st.getLastPrune === 'function' ? st.getLastPrune() : null
+      const limit = typeof st.retentionLimit === 'function' ? st.retentionLimit() : null
+      if (!last && limit === null) return null
+      return {
+        pruned: Number(last && last.pruned) || 0,
+        protected: Number(last && last.protected) || 0,
+        limit: limit === null || limit === undefined
+          ? (last && last.limit !== undefined ? last.limit : null)
+          : limit,
+        over: Number(last && last.over) || 0,
+        oldestAt: (last && last.oldestAt) || null,
+        at: (last && last.at) || null,
+      }
+    } catch (_) { return null }
+  }
+
   /** 把降级台账与配额测量**合并写入同一状态文件**（读驱动写；失败返回 false，不抛）。 */
   _persistObservabilityPre(snap, quota) {
     let persisted = false
@@ -6880,6 +7454,17 @@ class MemoryEngine {
         //   回答用户那两个问题：「配额太少（内容进不来）」还是「配额多了（白花 token）」。
         //   判定默认 `insufficient-data`（样本不足**不猜**），符合用户「基于长期观察」的要求。
         quota: this._quotaViewSnapshot(),
+        // ★#110（2026-09-22）：hub 三层记忆持久化 IO 健康度。与既有最小投影同一出口、同一纪律
+        //   （只出计数 + 人话原因 + 时间戳，**无路径、无原文**）。回答的问题：
+        //   「记忆到底写进磁盘了没有」——此前 save 失败被静默吞掉，面板/日志/返回值三处都看不出来。
+        hubIo: this._hubIoViewSnapshot(),
+        // ★P0-3（2026-09-22）：事实保留上限淘汰台账 —— 与既有最小投影同一出口、同一纪律
+        //   （只出聚合计数与时间戳，**无事实正文、无路径**）。此前 getLastPrune/retentionLimit
+        //   在双侧零调用方 ⇒「事实被悄悄淘汰了」在界面上无处可查。
+        factsPrune: this._factsPruneViewSnapshot(),
+        // ★2026-09-22（用户拍板）：诊断日志投影 —— 与既有最小投影同一出口、同一纪律。
+        //   回答：「日志在哪、多大、多少行」——用户不必再翻 PowerShell 或手动找目录。
+        logs: this._logsViewSnapshot(),
         runtimes: this.runtimes.values().map((rt) => ({
           key: rt.key,
           sessionId: rt.sessionId,
@@ -9094,8 +9679,11 @@ export function apply(ctx, config) {
   // 新bug修复①·启动预热(2026-09-08):重启后首轮 renderMemoryDynamic 可能先于 _doRefresh 完成,
   // 此时 globalLedgerPath 尚未就位,兜底行会错过它要救的那一轮。挂载即异步预热全局账本缓存(只读扫描,零副作用)。
   try { void engine.findLatestGlobalHandoff().then((v) => { if (!engine._globalLedgerCache) engine._globalLedgerCache = { at: Date.now(), value: v || '' } }).catch(() => {}) } catch (e) {}
+engine._recallStats = createRecallStatsPre({
+  file: () => path.join(dshHome(), 'memory', 'recall-stats.json'),
+})
   // M4-3:Shadow Retrieval Host 接线(三开关全开时才构造状态/IO;默认关闭零留存)
-  engine._shadowHost = createShadowHost({ engine })
+  engine._shadowHost = createShadowHost({ engine, onDiag: (key, msg) => diagThrottled(key, msg), recallStats: engine._recallStats })
   // M5-3:Context Bridge Host 接线(assoc+contextBridge 双门;默认关闭零构造/零 IO)
   engine._contextHost = createContextHost({ engine })
   // R3（2026-09-18）：降级台账。挂在引擎上，与各 host 同层 —— 跨臂统一，不分散到各 host。
@@ -9107,10 +9695,25 @@ export function apply(ctx, config) {
   //   注意：**绝不能**把常规观测塞进 `_degradeSink.record` —— 台账判据是「只记预期外失败」，
   //   混入后「有没有降级」将永远非空，降级信号被淹没。
   engine._quotaProbe = createQuotaProbePre({})
+// ③ 召回统计（2026-09-22 用户拍板「先只记录、不加权」）—— 数据源给面板「统计」页签。
+//   ★为什么只记录：加权会自我强化（召回多→权重高→更易被召回），在埋点口径被真实数据检验前加权
+//     会把口径错误放大成系统性偏差。故本模块**只累积计数并落盘**，召回排序与返回逐字节不变
+//     （守卫 smoke-test-recall-stats-pre.mjs 断言：埋点调用不改任何排序输入）。
+//   file 传**函数**而非字符串：DSH_HOME 可能在运行期变化，每次落盘重新解析路径。
+
   // 注：臂健康快照（deriveArmsHealthPre）在各臂执行路径上按实际情况标注，
   // 见 recall() 内 semantic/evidence 段与 _l0IndexSync 段。
   // M6-3:Activation Inbox Host 接线(assoc+activationInbox 双门;默认关闭)
   engine._activationHost = createActivationHost({ engine })
+  // ★issue#104（2026-09-22 移植自 PR #118 / 孤儿快照 475abfe）：把两个 host **回填给 runtime 释放路径**。
+  //   `SessionRuntimeStore.dispose()` 里按 `this._shadowHost` / `this._activationHost` 清理 per-runtime 态，
+  //   而这两个属性只挂在 engine 上 ⇒ 不回填则两处 `if` 恒假、清理恒不执行（激活态与 shadow 态随会话数单调增长）。
+  //   runtimes 在引擎构造期创建，早于各 host ⇒ 只能在此处回填。
+  //   ★回归警示：3.0.1 发布提交 53d20e7 曾整行删掉 activation 侧的回填，而旧测试只断言 dispose
+  //     函数体里的**字符串** ⇒ 静默回退。现由 smoke-test-issue103-105-portfix-pre.mjs 的「消费侧行为」
+  //     断言 + 本处「生产侧成对」断言双锁住守，删任一侧必红。
+  engine.runtimes._shadowHost = engine._shadowHost
+  engine.runtimes._activationHost = engine._activationHost
   // M7-8:Host Index Sync Orchestrator(四门全开才启用;默认关闭零 IO;修复 M7-8 Phase E blocker)
   engine._indexSyncHost = createIndexSyncHostPre({
     engine,
@@ -9135,20 +9738,36 @@ export function apply(ctx, config) {
   // (此前 io 缺省 no-op → 重启清零)。落盘为快照整体写,数据量有界(episodes≤retention/facts/过程中)。
   {
     const hubDir = path.join(dshHome(), 'memory', 'hub')
-    const hubIo = (name) => {
-      const f = path.join(hubDir, name)
-      return {
-        save(data) {
-          try { mkdirSync(hubDir, { recursive: true }); const tmp = f + '.tmp'; writeFileSync(tmp, JSON.stringify(data), 'utf8'); renameSync(tmp, f) } catch (_) {}
-        },
-        load() { try { return JSON.parse(readFileSync(f, 'utf8')) } catch (_) { return null } },
-        clear() { try { rmSync(f, { force: true }) } catch (_) {} },
-      }
-    }
+    // ★#110（2026-09-22）：hub 持久化 IO 失败**可见化**（实现已抽到 `hub-io.js`，本处只做接线）。
+    //   旧实现三个方法各自 `catch (_) {}` 静默吞异常，后果有两层：
+    //   ① 异常在**适配器这一层**就被吃掉 ⇒ 三店 A-8 的 `try { io.save() } catch` 永远走不到 catch 分支
+    //      ⇒ store 照样报 `{ok:true, persisted:true}`，上层统计与返回值全是绿的；
+    //   ② 用户侧表现为「记忆看着存上了，重启清零」，日志、计数、面板三处都拿不到信号。
+    //   现在：save/clear 失败**照原样抛出**（让 A-8 的既有 try/catch 真正生效）+ 每次失败记账到
+    //   `engine._hubIoHealth`（人话原因 + 累计次数 + 时间），经 debugInfo().associativeMemory.hubIo
+    //   与诊断日志（节流 5 分钟/键）输出；load 的「无文件/损坏 → null（空启动）」语义不变。
+    const hubIoHealth = createHubIoHealthPre()
+    engine._hubIoHealth = hubIoHealth
+    const hubIo = createHubIoPre({
+      dir: hubDir,
+      health: hubIoHealth,
+      onError: (key, msg) => diagThrottled('hubIo:' + key, msg),
+    })
+    // ★#110：把 io 工厂挂到 engine，供 hub 喂数循环做**批内合并落盘**（`beginBatch` / `endBatch`）。
+    //   喂数循环在另一个块作用域里，拿不到本块的 `hubIo` 局部变量，只能走 engine 这条既有通道。
+    engine._hubIoFactory = hubIo
+    // ★P0-3（2026-09-22）：事实库此前是**内联**创建在下面的 stores 字面量里、engine 上无引用。
+    //   这里提到局部常量并单独挂一份，供 debugInfo() 的只读投影（factsPrune）使用。
+    //   不改任何既有行为：stores.facts 仍是同一个实例，只是有了名字。
+    const factStore = createFactStorePre({ config: { maxFacts: Number(engine.config.factRetentionMax) || 1000 }, io: hubIo('facts.json') })
+    engine._factStore = factStore
     engine._memoryHub = createMemoryHubPre({
+      // issue #110：把 io 工厂的批控制交给 hub 本身 ⇒ 所有批量喂数入口（喂数循环、HTTP
+      // `action=feed`、将来的重放器）都自动「一批一次落盘」，不必各自记得在外面 begin/end。
+      batch: hubIo,
       stores: {
         episodic: createEpisodicStorePre({ config: { minSegments: Number(engine.config.episodicMinSegments) || 2, retention: Number(engine.config.episodicRetention) || 256 }, io: hubIo('episodes.json') }),
-        facts: createFactStorePre({ io: hubIo('facts.json') }),
+        facts: factStore,
         procedures: createProcedureStorePre({
           // 2026-08-30 修复:gates 用 getter 活读 engine.config——挂载(apply 同步)时
           // engine.config 尚未 loadConfig,静态读会冻结 DEFAULT(3/2),设置页改门槛永不生效
@@ -9156,7 +9775,7 @@ export function apply(ctx, config) {
             // 0 值合法(验证用);仅非有限负值回退默认——不可用 || 0 会 falsy 穿透
             get minSessionDiversity() { const v = Number(engine.config.procedureMinSessions); return (Number.isFinite(v) && v >= 0) ? v : 3 },
             get minSuccessCount() { const v = Number(engine.config.procedureMinSuccess); return (Number.isFinite(v) && v >= 0) ? v : 2 },
-            get maxCorrectionRate() { return Number(engine.config.procedureCorrectionCap) || 0.3 },
+            get maxCorrectionRate() { const v = Number(engine.config.procedureCorrectionCap); return (Number.isFinite(v) && v >= 0) ? v : 0.3 },
             get maxContradictions() { return 0 },
             get highRiskRequiresApproval() { return engine.config.procedureHighRiskApproval !== false },
           },
@@ -9204,7 +9823,15 @@ export function apply(ctx, config) {
   // 写回:P1④ 主闭环——hub.facts 中 confirmed/未过期/未撤销/置信≥0.6 的事实,每日限额
   // 治理式写入 notesPath/userFile(autoConsolidate 同款 appendText 原子事务)→ 进 M7 语料。
   {
-    const hubFeedState = { shadow: null } // 文件指纹 {size,mtimeMs,count}
+    const hubFeedState = { shadow: null } // 文件指纹 {size,mtimeMs}
+    // ★issue#103（2026-09-22 移植自 PR #119）：环形 JSONL 的增量游标 —— **内容指纹**，替代原来的行数游标。
+    //   为什么不能用行数：该文件由 Python 侧按「保尾丢弃」维护（SHADOW_LOG_MAX=256，每次重写为
+    //   lines[-256:]）⇒ 写满后 lines.length 恒等于上次的 count，增量区间恒为空 ⇒ 消费端永久停摆，
+    //   且因为「没有新行」是合法状态而**不留任何痕迹**、事后不可发现。
+    //   maxSeen 取环形上限 256 的 4 倍，避免指纹被淘汰后旧行被重复交付。
+    //   ★本次移植实测教训：锚点不匹配会让整块补丁被静默跳过，而 `node --check` 与静态守卫**都不会报**
+    //     （引用在另一处）⇒ 运行期才炸 ReferenceError。故补丁脚本必须配「声明与使用成对」的哨兵断言。
+    const hubFeedCursor = createJsonlTailCursorPre({ maxSeen: 1024 })
     const hubFlushState = { date: '', count: 0, flushed: {} } // flushed[factId]=true;持久化 hub/flush-state.json
     const hubFlushFile = () => path.join(dshHome(), 'memory', 'hub', 'flush-state.json')
     const hubFlushLoad = () => {
@@ -9250,33 +9877,49 @@ export function apply(ctx, config) {
         const f = path.join(dshHome(), 'memory', 'semantic', 'judgement-shadow.jsonl')
         let st
         try { st = statSync(f) } catch (_) { return }
-        const prev = hubFeedState.shadow
-        if (prev && prev.size === st.size && prev.mtimeMs === st.mtimeMs) return
         const lines = readFileSync(f, 'utf8').split('\n').filter((l) => l.trim())
-        const start = prev && lines.length >= prev.count ? prev.count : lines.length // 文件被截断则只取尾部
+        // ★issue#103（2026-09-22 移植自 PR #119）：游标**不能再用行数**。该文件由 Python 侧按
+        //   「保尾丢弃」维护（SHADOW_LOG_MAX=256，每次重写为 lines[-256:]）⇒ 写满后 lines.length 恒等于
+        //   上次的 count，增量区间恒为空、消费端永久停摆，而且"没有新行"是合法状态、不留任何痕迹。
+        //   改为行内容指纹：环内每行只交付一次，与截断无关。（首次 take() 只登记现状不喂历史行，
+        //   避免重启后把环里旧判据再吃一遍导致 observe 重复计数。）
+        const cursor = (hubFeedCursor.take(lines).fresh)
         const newRows = []
-        for (let i = start; i < lines.length; i++) {
-          try { const d = JSON.parse(lines[i]); if (d && d.kindCandidate) newRows.push(d) } catch (_) {}
+        for (let i = 0; i < cursor.length; i++) {
+          try { const d = JSON.parse(cursor[i]); if (d && d.kindCandidate) newRows.push(d) } catch (_) {}
         }
-        hubFeedState.shadow = { size: st.size, mtimeMs: st.mtimeMs, count: lines.length }
+        hubFeedState.shadow = { size: st.size, mtimeMs: st.mtimeMs }
         if (!newRows.length) return
         // 异步富化+喂送(不阻塞 tick);单行失败静默
         void (async () => {
           let fed = 0
-          for (const row of newRows) {
-            try {
-              const src = Array.isArray(row.sourceIds) ? row.sourceIds[0] : null
-              if (src) {
-                const rec = await hubCorpusLookup(src)
-                if (rec) {
-                  row.subject = String(rec.heading || rec.text || '').split('\n')[0].slice(0, 30)
-                  row.predicate = '记录要点'
-                  row.object = String(rec.text || '').slice(0, 120)
+          // ★#110（2026-09-22）：批内合并落盘 —— 旧实现每行一次 upsert ⇒ **一次整份快照写盘**，
+          //   一批 N 行就是 N 次写放大。这里用 hubIo 的批控制把整批收敛成「批末最多一次/文件」。
+          //   批末一定 flush（finally），任何一行抛错也不会把已接受的改动留在内存不落盘。
+          const ioFactory = engine._hubIoFactory
+          try {
+            if (ioFactory && typeof ioFactory.beginBatch === 'function') ioFactory.beginBatch()
+            for (const row of newRows) {
+              try {
+                const src = Array.isArray(row.sourceIds) ? row.sourceIds[0] : null
+                if (src) {
+                  const rec = await hubCorpusLookup(src)
+                  if (rec) {
+                    row.subject = String(rec.heading || rec.text || '').split('\n')[0].slice(0, 30)
+                    row.predicate = '记录要点'
+                    row.object = String(rec.text || '').slice(0, 120)
+                  }
                 }
-              }
-              const r = hub.ingestJudgement(row)
-              if (r && r.consumed) fed++
-            } catch (_) {}
+                const r = hub.ingestJudgement(row)
+                if (r && r.consumed) fed++
+              } catch (_) {}
+            }
+          } finally {
+            if (ioFactory && typeof ioFactory.endBatch === 'function') {
+              const b = ioFactory.endBatch()
+              if (b && b.written) diag('hub feed batch: ' + b.written + ' 份快照批量落盘（合并 ' + newRows.length + ' 行喂入）')
+              if (b && b.ok === false) diag('hub feed batch: 有快照落盘失败 —— 原因见 hubIo 健康度（debugInfo().associativeMemory.hubIo）')
+            }
           }
           if (fed) diag('hub feed: +' + fed + '/' + newRows.length + ' rows consumed')
         })()
@@ -9852,6 +10495,9 @@ export function apply(ctx, config) {
         try { if (engine._ownSubagents && engine._ownSubagents.has(agent)) return } catch (e) {}
         // 最后活动时间写入该 agent 自己的 runtime(不再落到 currentRuntime()/default)
         try { engine.runtimeFor(agent).lastActiveAt = Date.now() } catch (e) {}
+        // ★2026-09-22(用户拍板):新工作区自动首建白板骨架 —— 只写一次、fail-soft、不阻塞收尾。
+        //   放在水位测量之前:首建是"产物存在性"兜底,与水位阈值无关,新工作区首轮就该落下来。
+        try { void engine.ensurePlanBoardForAgentPre(agent).catch(function () {}) } catch (eSeed) {}
         // M-CM4 水位感知:每轮测量会话消息体量,越阈值→advisory+自动骨架账本(异步,不阻塞收尾)
         try { void engine.checkWaterLevel(agent).then(function () {
           // M-CM6-C 宿主兜底:轮末测量完成后若达标 → arm 倒计时(浏览器活着时由它展示确认卡;被节流/关闭则宿主到期自执行)
@@ -10113,7 +10759,7 @@ export function apply(ctx, config) {
       return '已更新记忆文档: ' + logPath + '\n' + entry + (gate.truncated ? '\n(内容超长,已截断)' : '')
     }),
 
-    defineTool('memory_note', '更新当前项目长期笔记 .dsh-memory/MEMORY.md(本项目专属的约定、决策、架构要点),或写交接白板。kind=note(默认):action=append 追加一段(自动带日期标题)/action=replace 整体替换(需先基于注入内容或 memory_recall 结果给出完整新内容),本项目笔记有**容量上限**(字符,设置项 noteCapacityChars,默认 24000);**超出时的行为**(你不需要自己控制长度,写就是):①先把较早内容交给 AI 折叠成要点(同一层 10 分钟内只整理一次);②整理失败则**整条原文**归档到 `.dsh-memory/archive/`(信息不丢);③整理后仍超才拒绝(正常不会发生)。kind=handoff:写一篇四段式交接账本(任务状态/目标/已试方案与失败原因/进度与下一步)到 handoff/,阶段产出或方向变化时用,给下一个上下文窗口续命;**账本/白板内容要落进面板看板泳道,须在标题或正文写 tag**:type:goal / type:state / type:dead-end / type:progress。kind=plan:整体重写白板 PLAN.md(人能读的项目全貌规划图),对项目全貌的理解发生实质变化时用,旧版自动归档。**结论失效时的两个通道(不要混用)**:supersedes=被更新结论取代(有后继);retract=**当时就做错了、直接撤回**(无后继,本身即教训)。**调用后必须在本轮回复正文中向用户转述:更新了什么**。', {
+    defineTool('memory_note', '更新当前项目长期笔记 .dsh-memory/MEMORY.md(本项目专属的约定、决策、架构要点),或写交接白板。kind=note(默认):action=append 追加一段(自动带日期标题)/action=replace 整体替换(需先基于注入内容或 memory_recall 结果给出完整新内容),本项目笔记有**容量上限**(字符,设置项 noteCapacityChars,默认 24000);**超出时的行为**(你不需要自己控制长度,写就是):①先把较早内容交给 AI 折叠成要点(同一层 10 分钟内只整理一次);②整理失败则**整条原文**归档到 `.dsh-memory/archive/`(信息不丢);③整理后仍超才拒绝(正常不会发生)。kind=handoff:写一篇四段式交接账本(任务状态/目标/已试方案与失败原因/进度与下一步)到 handoff/,阶段产出或方向变化时用,给下一个上下文窗口续命;**账本/白板内容要落进面板看板泳道,须在标题或正文写 tag**:type:goal / type:state / type:dead-end / type:progress。kind=plan:整体写入/重写白板 PLAN.md(人能读的项目全貌规划图)。**首建亦可**——工作区若还没有白板,宿主已自动落了一版骨架,你理解全貌后直接整体重写成真内容即可;对项目全貌的理解发生实质变化时同样重写。旧版自动归档。**别把骨架留在那里当白板**。**结论失效时的两个通道(不要混用)**:supersedes=被更新结论取代(有后继);retract=**当时就做错了、直接撤回**(无后继,本身即教训)。**调用后必须在本轮回复正文中向用户转述:更新了什么**。', {
       content: { type: 'string', required: true, description: '笔记内容。kind=plan 时给完整新全貌(不是增量)。' },
       action: { type: 'string', enum: ['append', 'replace'], description: '仅 kind=note 时有效:append=追加, replace=整体替换。' },
       kind: { type: 'string', enum: ['note', 'handoff', 'plan'], description: 'note=项目笔记(默认), handoff=四段式交接账本(新篇), plan=白板全貌重写。' },
@@ -10150,7 +10796,13 @@ export function apply(ctx, config) {
         else { engine.state.latestHandoffText = '# 交接账本 · ' + engine.memToday() + ' ' + nowHm() + '\n\n' + ((r && r.clean) || writeH); engine.state.loadedAt = Date.now() }
         return (args.kind === 'plan'
           ? '白板 PLAN.md 已更新' + (r.archived ? '(旧版已归档: ' + r.archived + ')' : '(首建)') + ': ' + r.path
-          : '交接账本已写入: ' + r.path) + '\n请在本轮回复正文向用户转述本次更新要点。'
+          : '交接账本已写入: ' + r.path)
+          // ★ 2026-09-21 bugfix(A-2):handoff 此前**静默截断** —— sanitizeForWrite 超限时是
+          //   「截断 + truncated:true」返回 ok(:8625-8628),而本分支接住了 gateH 却从不外显该标志
+          //   (对照 note 分支 :10184 会拼提示)。账本四段固定以「进度与下一步」结尾,截断恰好砍掉它,
+          //   模型却收到「已写入」⇒ 跨窗口续命材料无声缩水。现与 note 分支对齐。
+          + (gateH.truncated ? '\n⚠ 账本超长已截断到 ' + writeH.length + ' 字符(上限 ' + (args.kind === 'plan' ? 200000 : 8000) + '),尾部「进度与下一步」可能已丢失 —— 请精简后重写。' : '')
+          + '\n请在本轮回复正文向用户转述本次更新要点。'
       }
       const replace = args.action === 'replace'
       // 写闸门: append 单条上限 8000 字; replace(整篇重写)放行到 20 万字, 但同样经受乱码/复读/重复块质量闸门
@@ -10322,12 +10974,47 @@ export function apply(ctx, config) {
       title: { type: 'string', required: true, description: '事项标题。' },
     }, async (args, exec) => engine.calendarRemove(args.date, args.time, args.title, exec.agent)),
 
+    defineTool('memory_rules', '用户级硬性约束(每轮无条件注入的 [规则] 段,真源 ~/.dsh/memory/MEMORY.md)的**条目级增删改**。op=list 列出全部条目(0 基序号/来源日期段/文本);op=add 追加;op=update 改写一条;op=remove **真删**一条。★**删/改必须带 expect**(=该条**当前**文本,从 list 原样回填),不符即拒 —— 防索引漂移删错行。★这段**每轮注入且不参与裁剪**,所以它同时是 prompt 成本的主要来源:清理过时条目的首选手段就是本工具的 remove(而不是把整篇用户级记忆用 memory_user replace 重写)。★status 被标 superseded/retracted 的条目自 P9 起**不再进规则段**,但仍留在 list 里(要彻底消失用 remove;要软失效用 memory_note 的 retract/supersedes)。**调用后必须在本轮回复正文中向用户转述改了什么**。', {
+      op: { type: 'string', enum: ['list', 'add', 'update', 'remove'], required: true, description: 'list=列出; add=追加; update=改写一条(需 index+expect+content); remove=真删一条(需 index+expect)。' },
+      index: { type: 'number', description: '条目序号(0 基,来自 op=list 的顺序)。' },
+      expect: { type: 'string', description: '该条**当前**文本(内容锚定,防索引漂移)。update/remove 必填。' },
+      content: { type: 'string', description: 'update/add 的新文本(单行,≤2000 字符)。' },
+      dateSection: { type: 'string', description: 'add 可选:追加到指定日期段(YYYY-MM-DD);缺省追加到文件头部(用户手写区)。' },
+    }, async (args) => {
+      const op = String(args.op || '')
+      if (op === 'list') {
+        const r0 = await applyRuleEditPre(engine, 'list', {})
+        if (!r0.ok) return 'memory_rules: ' + r0.error
+        const rows = (r0.items || []).map((x, i) => '[' + i + '] (' + x.source + (x.dateSection ? ' ' + x.dateSection : '') + ') ' + x.text)
+        let extra = ''
+        try {
+          const lay = extractRulesLayerPre({ userText: await engine.readTextSafe(r0.path), rulesLayeringMode: 'self' })
+          const n = (lay.retired || []).length
+          if (n) extra = '\\n注:其中 ' + n + ' 条 status≠current,**已不再进规则段**(仍可用 remove 真删)。'
+        } catch (_) {}
+        return '用户级硬约束共 ' + rows.length + ' 条(0 基):\\n' + rows.join('\\n') + extra
+      }
+      if (op === 'add') {
+        const gate = sanitizeForWrite(String(args.content || ''), { maxEntryChars: 2000 })
+        if (!gate.ok) return 'memory_rules: 写入被记忆卫生闸门拦截(' + WRITE_GATE_REASON[gate.reason] + '),未写入。请改写为客观陈述后重试。'
+        const ra = await applyRuleEditPre(engine, 'add', { text: gate.clean || String(args.content || ''), dateSection: args.dateSection })
+        if (!ra.ok) return 'memory_rules: ' + ra.error
+        return '已追加规则,现共 ' + (ra.items || []).length + ' 条。\\n' + ra.preview
+      }
+      const r = await applyRuleEditPre(engine, op, { index: args.index, expect: args.expect, text: args.content }, { requireExpect: true })
+      if (!r.ok) return 'memory_rules: ' + r.error
+      return (op === 'remove' ? '已删除' : '已改写') + '第 ' + args.index + ' 条,现共 ' + (r.items || []).length + ' 条。\\n' + r.preview
+    }),
+
     defineTool('memory_consolidate', 'AI 主动维护长期记忆(做梦式固化):读最近 days 天的工作日志,由 AI 发散提炼出有跨会话长期价值的决策/架构/用户偏好,自动写入项目笔记 MEMORY.md(带日期标题)与用户级 MEMORY.md(跨项目规则),并在正文向用户转述固化结果。★**与「自动沉淀」的边界**:每轮对话结束框架会**自动**评估并写日志/升格要点,**你不需要为日常轮次做这件事**;本工具是**你主动发起的加料**——隔一段时间(或一个阶段收尾时)用来做一次更彻底的提炼,读的是**多日日志**、输出进项目笔记与用户级记忆。⇒ 用它做「阶段性固化」,不要用它替代每轮的 memory_log。', {
       days: { type: 'integer', description: '读取最近 N 天日志,缺省 7,上限 30。' },
     }, async (args, exec) => engine.consolidateMemory(exec.agent, Math.min(Math.max(Number(args.days) || 7, 1), 30))),
 
     // ★★★ T4（2026-09-19 用户拍板「让大模型来介入 procedure memory」）★★★
-    // **工具数 16→17**（无条件注册；四处硬锁联动：smoke-test.mjs / m3b3 / context-observer / graph-mode）。
+    // **工具数 17→18**（无条件注册；P9 新增 memory_rules）。★硬锁联动**六处**（原注释只写四处，
+  //   实测还漏了 p23-wb-sidecar 与 docs/HANDBOOK.md §6 表 ⇒ 加工具时一并改）：
+  //   tests/smoke/smoke-test.mjs / m3b3-pre / context-observer / graph-mode-pre / p23-wb-sidecar-pre / docs/HANDBOOK.md。
+  //   另有发版侧两表必然漏登记（memory_rules，见 tools/release.mjs 的 T7-e 注与 smoke-test-t7e）。
     // 背景：此前三条记忆线（episodic / semantic / procedural）**全部只有机械生成**，
     //   模型没有任何写入通路。procedural 线的唯一来源是 `memory-hub.js` 的 crossFeed：
     //   它把每个"成功 episode"机械切成候选，而 episode 的 actions 就是 `['user','user','user']`
@@ -10383,8 +11070,26 @@ export function apply(ctx, config) {
         // —— action=activate：模型授权跳统计门 → 晋升 → 激活 → 导出 SKILL.md ——
         const pr = procs.promote(pid, {}, { authorizedBy: 'model' })
         if (!pr || !pr.ok || pr.decision !== 'promote') {
+          // ★ B-1 配套(用户 2026-09-22 方针①「模型友好」+ ②「原因要人能看懂」)：
+          //   旧文案只甩 decision + reasonCodes 机器码，模型读完不知道下一步该做什么，
+          //   遇到 high-risk 就以为"卡死了"。现在补一层**人话解释 + 可执行的下一步**，
+          //   机器码原样保留（便于日志/前端复用），模型据此能自己决定是补 successCriteria、
+          //   还是提示用户去「记忆中枢」点「批准」。
+          const codes = ((pr && pr.reasonCodes) || []).map(String)
+          const EXPLAIN = {
+            'high-risk-awaiting-approval': '该条被标为高风险，需要**用户在「记忆中枢」页签点「批准」**后才能晋升（批准只解这一道门，其余门槛不变）。你可以告诉用户这条待批准。',
+            'no-success-criteria': '缺少 successCriteria ⇒ 结构上无法晋升。请用 memory_procedure 补写「怎么算跑通」再调 action=activate。',
+            'observation-only': '这条是纯 episode 观察行（没有 steps/successCriteria），设计上不参与晋升；请改为写入一条真正的技能条目。',
+            'has-correction': '该条存在纠正记录（maxContradictions=0）⇒ 先解决矛盾，不要强推。',
+          }
+          const c3 = codes[0]
+          const human = EXPLAIN[c3] || (codes.find((c) => EXPLAIN[c]) ? EXPLAIN[codes.find((c) => EXPLAIN[c])] : '')
+          const corrCode = codes.find((c) => c.startsWith('correction-rate-'))
           return out + '\n未激活：晋升未通过（decision=' + String((pr && pr.decision) || '?') +
-            ' reasonCodes=' + JSON.stringify((pr && pr.reasonCodes) || []) + '）。条目仍在审批列表。'
+            ' reasonCodes=' + JSON.stringify(codes) + '）。条目仍在审批列表。' +
+            (human ? '\n→ ' + human : '') +
+            (corrCode ? '\n→ 纠正率超过当前上限（' + corrCode + '）：说明该条历史执行里被纠正过，先改进流程再重试。' : '') +
+            (codes.includes('diversity-below-3') ? '\n→ 跨会话证据不足（需要至少 3 个不同会话的成功记录）：继续在别的会话里用一次，或由用户手动晋升。' : '')
         }
         const ar = procs.activate(pid)
         if (!ar || !ar.ok) return out + '\n已晋升但激活失败：' + String((ar && ar.reason) || 'unknown')
@@ -10889,7 +11594,24 @@ export function apply(ctx, config) {
             const body = await readJsonBody(req).catch(() => ({}))
             const action = String((body && body.action) || '')
             if (action === 'consolidate') return writeJson(res, 200, hub.consolidateEpisodes())
-            if (action === 'feed') return writeJson(res, 200, hub.ingestJudgementRows(Array.isArray(body.rows) ? body.rows : []))
+            if (action === 'feed') {
+              // ★#110（2026-09-22）：HTTP feed 入口也要走批内合并落盘 —— 旧实现直调 ingestJudgementRows，
+              //   每行一次 upsert 就是一次整份快照写盘（N 行 = N 次写放大）。批控制与 hub 喂数循环同源，
+              //   挂在 engine._hubIoFactory；批末一定 flush（finally），任何行抛错也不会把已接受的改动留在内存。
+              const rows = Array.isArray(body.rows) ? body.rows : []
+              const ioFactory = engine._hubIoFactory
+              let fedResult
+              try {
+                if (ioFactory && typeof ioFactory.beginBatch === 'function') ioFactory.beginBatch()
+                fedResult = hub.ingestJudgementRows(rows)
+              } finally {
+                if (ioFactory && typeof ioFactory.endBatch === 'function') {
+                  const b = ioFactory.endBatch()
+                  if (b && b.ok === false) diag('hub feed(http) batch: 有快照落盘失败 —— 原因见 hubIo 健康度（debugInfo().associativeMemory.hubIo）')
+                }
+              }
+              return writeJson(res, 200, fedResult)
+            }
             if (action === 'render') return writeJson(res, 200, { checklists: hub.renderChecklists() })
             if (action === 'crossfeed') return writeJson(res, 200, hub.crossFeed(String((body && body.sessionRef) || '')))
             // M9 审批动作(2026-08-30,G-02 同款 loopback+append-only 精神):用户在 hubTab
@@ -10897,11 +11619,29 @@ export function apply(ctx, config) {
             // 不绕过任何 gate;每次动作进 diagnose 审计。
             const procs = hub.stores && hub.stores.procedures
             const pid = String((body && body.procedureId) || '')
-            if (['promote', 'activate', 'deprecate', 'pin'].includes(action)) {
+            // ★ B-1 修复(2026-09-22)：白名单补 `approve`。
+            //   旧白名单只有 promote/activate/deprecate/pin，而高风险条目建候选时恒 `approved:false`
+            //   （procedure-store.js:235）且全仓无任何代码能置真，promote 只会返回 decision:'ask'
+            //   ⇒ 高风险条目的晋升是**死路**。现在把"人来确认"这只手补上：approve 只解一道门，
+            //   其余五道结构门（已弃用 / 观察型 / 缺 successCriteria / 纠正率超限 / 存在纠正）照旧拦。
+            // ★B（2026-09-22）：白名单补 `force-promote`（人工**强制晋升**）。
+            //   动机（有数据证据）：只读投影 evaluatePromotion 对盘上 30 条**全部**返回 keep，
+            //   ⇒ 按 A-9 的门控，界面上一个可点的晋升按钮都没有（"手动通道看起来被关掉了"）。
+            //   其中「只被 diversity/success 两道统计门拦住」的行（实际 14 条里绝大多数）
+            //   在语义上是可以人工越过的 —— promote() 的 `if (!authorizedBy)` 正是为这场景留的口子。
+            if (['promote', 'force-promote', 'approve', 'activate', 'deprecate', 'pin'].includes(action)) {
               if (!procs) return writeJson(res, 200, { ok: false, reason: 'no-procedure-store' })
               if (!pid) return writeJson(res, 400, { error: 'procedureId required' })
               let r
-              if (action === 'promote') r = procs.promote(pid)
+              if (action === 'approve') r = procs.approve(pid, 'user')
+              else if (action === 'promote') r = procs.promote(pid)
+              // ★B（2026-09-22）：人工强制晋升 —— `authorizedBy:'user'`。
+              //   · 只越过 diversity / success 两道**统计门**；
+              //   · 结构门（deprecated / observationOnly / no-success-criteria / has-correction /
+              //     correction-rate / 高风险待批准）**照旧拦** —— 与 T4 冻结的"授权语义"逐字一致；
+              //   · 留痕：晋升成功会写 `p.authorizedBy = 'user'`，reasonCodes 记 `user-authorized`，
+              //     与模型授权（`model-authorized`）在审计面可区分。
+              else if (action === 'force-promote') r = procs.promote(pid, {}, { authorizedBy: 'user' })
               else if (action === 'activate') {
                 r = procs.activate(pid)
                 // ★ ⑪-2（用户 2026-09-19 拍板）：晋升为 active 后**自动导出** SKILL.md。
@@ -11083,6 +11823,46 @@ export function apply(ctx, config) {
         } catch (e) { writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
       },
     },
+    {
+      kind: 'exact',
+      path: API['migrate-export'],
+      handler: async (req, res) => {
+        // 迁移搬包 P1：导出。loopback-only（记忆含隐私，绝不对外）。
+        if (!isLoopbackRequest(req)) return writeJson(res, 403, { error: 'forbidden: loopback-only' })
+        if ((req.method || 'POST') !== 'POST') return writeJson(res, 405, { error: 'method not allowed' })
+        const body = await readJsonBody(req).catch(() => ({}))
+        try {
+          const ws = String((body && body.ws) || (engine._lastAgent && engine._lastAgent.cwd) || '')
+          writeJson(res, 200, await engine.migrateExport({ ws, outPath: body && body.outPath, compress: !(body && body.compress === false) }))
+        } catch (e) { writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
+      },
+    },
+    {
+      kind: 'exact',
+      path: API['migrate-inspect'],
+      handler: async (req, res) => {
+        // 迁移搬包 P2：预览差异（只读，不写任何文件）。
+        if (!isLoopbackRequest(req)) return writeJson(res, 403, { error: 'forbidden: loopback-only' })
+        if ((req.method || 'POST') !== 'POST') return writeJson(res, 405, { error: 'method not allowed' })
+        const body = await readJsonBody(req).catch(() => ({}))
+        try {
+          writeJson(res, 200, await engine.migrateInspect({ packPath: body && body.packPath, targetWs: body && body.targetWs, onConflict: body && body.onConflict, rewriteBody: !(body && body.rewriteBody === false) }))
+        } catch (e) { writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
+      },
+    },
+    {
+      kind: 'exact',
+      path: API['migrate-import'],
+      handler: async (req, res) => {
+        // 迁移搬包 P3：执行（先备份后落盘；冲突默认 keep）。
+        if (!isLoopbackRequest(req)) return writeJson(res, 403, { error: 'forbidden: loopback-only' })
+        if ((req.method || 'POST') !== 'POST') return writeJson(res, 405, { error: 'method not allowed' })
+        const body = await readJsonBody(req).catch(() => ({}))
+        try {
+          writeJson(res, 200, await engine.migrateImport({ packPath: body && body.packPath, targetWs: body && body.targetWs, onConflict: body && body.onConflict, rewriteBody: !(body && body.rewriteBody === false) }))
+        } catch (e) { writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
+      },
+    },
     {
       kind: 'exact',
       path: API.debug,
@@ -11159,6 +11939,28 @@ export function apply(ctx, config) {
       },
     },
     {
+    kind: 'exact',
+    path: API.recallStats,
+    handler: async (req, res) => {
+      if (!isLoopbackRequest(req)) return writeJson(res, 403, { error: 'forbidden: loopback-only' })
+      const method = req.method || 'GET'
+      // 只读：GET 取快照；POST 仅用于显式复位（面板按钮），同样 loopback-only。
+      if (method !== 'GET' && method !== 'POST') return writeJson(res, 405, { error: 'method not allowed' })
+      try {
+        if (!engine._recallStats) return writeJson(res, 200, { enabled: false })
+        if (method === 'POST') {
+          const url = new URL(req.url || '/', 'http://localhost')
+          if (url.searchParams.get('reset') === '1') {
+            engine._recallStats.reset()
+            return writeJson(res, 200, { ok: true, reset: true })
+          }
+          return writeJson(res, 400, { error: 'unknown action' })
+        }
+        writeJson(res, 200, { enabled: true, stats: engine._recallStats.snapshot() })
+      } catch (e) { writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
+    },
+  },
+  {
       kind: 'exact',
       path: API.updateCheck,
       handler: async (req, res) => {
@@ -11205,7 +12007,15 @@ export function apply(ctx, config) {
         const method = req.method || 'GET'
         try {
           if (method === 'GET') {
-            writeJson(res, 200, { config: await engine.loadConfig(), path: engine._configPath })
+            // ★P10-T1（2026-09-22）：把「可关的注入分区」清单**从宿主常量发给前端**——设置页
+            // 二级页据此枚举开关，前端不得硬编码第二份清单（守卫断言集合相等）。
+            // 搭本路由的便车而非新开路由：避免 API 路径锁（A1/A2/A4）三处同步的额外风险。
+            writeJson(res, 200, {
+              config: await engine.loadConfig(),
+              path: engine._configPath,
+              promptSections: PROMPT_SECTION_KEYS_V1,
+              promptSectionMust: PROMPT_SECTION_MUST_V1,
+            })
             return
           }
           if (method === 'POST' || method === 'PUT') {
@@ -11224,6 +12034,22 @@ export function apply(ctx, config) {
                 patch[key] = body[key].map((x) => x.trim()).filter(Boolean)
                 continue
               }
+              // ★#117 P3-20②（2026-09-22）：路径类键 fail-closed —— 旧实现对绝大多数键裸赋值，
+              //   而 memoryRoot / userMemoryDir 就在 DEFAULT_CONFIG 键集内 ⇒ 一次 POST 可把后续
+              //   append/rewrite 的落点移出记忆区。判据：非空字符串 + 展开后必须落在 dshHome() 之下。
+              //   注意：① 必须先经 expandUserPath 展开（默认值本身就带 `~`，否则默认值过不了自己的闸）；
+              //        ② 用 path.relative 判，纯 startsWith 会漏放行 `~/.dsh/memory-backup` 这类前缀兄弟目录。
+              //   通过校验后仍存**原样**（保持 DEFAULT_CONFIG 的 `~` 形书写约定），与 injectExcludeSources 同款 fail-closed 丢弃。
+              if (key === 'memoryRoot' || key === 'userMemoryDir') {
+                const rawPath = body[key]
+                if (typeof rawPath !== 'string' || !rawPath.trim()) continue
+                const expanded = engine.expandUserPath(rawPath)
+                if (typeof expanded !== 'string' || !path.isAbsolute(expanded)) continue
+                const rel = path.relative(dshHome(), expanded)
+                if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) continue
+                patch[key] = rawPath
+                continue
+              }
               patch[key] = body[key]
             }
             const saved = await engine.saveConfig(patch)
@@ -11293,22 +12119,11 @@ export function apply(ctx, config) {
         const op = String((body && body.op) || '')
         if (!['add', 'update', 'remove'].includes(op)) return writeJson(res, 400, { error: 'invalid-op' })
         try {
-          const p = await engine.resolvePaths(undefined)
-          const before = (await engine.readTextSafe(p.userFile)) || ''
-          let r
-          if (op === 'add') r = appendRuleItemPre(before, body.text, { dateSection: body.dateSection })
-          else if (op === 'update') r = updateRuleItemPre(before, Number(body.index), body.text)
-          else r = removeRuleItemPre(before, Number(body.index))
-          if (!r.ok) return writeJson(res, 400, { error: '编辑被拒: ' + r.error })
-          // ★ 复用既有事务（备份 + 校验 + anchor 处理），绝不绕过
-          const written = await engine.writeFull(p.userFile, r.text)
-          const after = (await engine.readTextSafe(p.userFile)) || written || r.text
-          const items = listRuleItemsPre(after)
-          writeJson(res, 200, {
-            result: op + ' ok',
-            items,
-            preview: items.map((x) => '- ' + x.text).join('\n'),
-          })
+          // ★P9：与模型工具 memory_rules 共用同一写盘口（requireExpect 保持 false ——
+          //   R7 的设计是「前端做二次确认，host 侧只如实执行」，不在此处引入第二套语义）
+          const r = await applyRuleEditPre(engine, op, { index: body.index, text: body.text, dateSection: body.dateSection })
+          if (!r.ok) return writeJson(res, r.error === 'invalid-op' ? 400 : 400, { error: r.error })
+          writeJson(res, 200, { result: op + ' ok', items: r.items, preview: r.preview })
         } catch (e) { writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
       },
     },
@@ -11503,7 +12318,7 @@ export function apply(ctx, config) {
         pid: process.pid,
         heartbeatAt: Date.now(),
         uptimeMs: Math.round(process.uptime() * 1000),
-        queueLength: q.length,
+        queueLength: q,
         lastConsolidatedAt: (engine.autoStats && engine.autoStats.lastAt) || 0,
         todayCount: (engine.autoStats && engine.autoStats.count) || 0,
       }, null, 2), 'utf8')
@@ -11570,3 +12385,5 @@ export function apply(ctx, config) {
 
 /** 导出卫生守卫与脏 token 检查器(供 smoke-test / 回归测试直接调用)。 */
 export { sanitizeForWrite, hygieneGateForPrimitive, dirtyScanForFiles, mojibakeDensity, tailHas, hasStutter, WRITE_GATE_REASON, foldSessionLogEvents, workspaceIdForSession, attachmentsOfContent, attachmentBlobPathsPre, renderAttachmentLinesPre }
+/** 导出会话运行态仓库(issue#104)：让 dispose 的清理接线能被行为测试直接驱动，不必靠断言源码字符串。 */
+export { SessionRuntimeStore }