@a9i5k4/dsh-auto-memory 0.1.28 → 0.1.30

package/lib/index.js

@@ -18,19 +18,43 @@
  */
 
 import { readFile, writeFile, mkdir, readdir, stat, rm, copyFile, appendFile } from 'node:fs/promises'
-import { createReadStream, existsSync } from 'node:fs'
+import { createReadStream, existsSync, readFileSync, writeFileSync, mkdirSync, renameSync, rmSync, statSync } from 'node:fs'
 import { exec as cpExec } from 'node:child_process'
 import { promisify } from 'node:util'
 const execP = promisify(cpExec)
 import { homedir } from 'node:os'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { MemoryDocumentStore } from './memory-writer.js'
+import { parseAnchors } from './memory-anchor.js'
+import { createShadowHost } from './shadow-host.js'
+import { createContextHost } from './context-host.js'
+import { createSuccessEvidencePre } from './context-bridge.js'
+import { createIndexSyncHostPre } from './m7-index-sync-host.js'
+import { createActivationHost } from './activation-host.js'
+import { createJsSemanticEnginePre, createSemanticDownloaderPre, fuseD6Pre, E5_SMALL_Q8_MANIFEST_V1 } from './semantic-js.js'
+import { loadAndVerifyPolicy, decideActivationV2, lexicalContainment } from './semantic-decide.js'
+import { createPythonSidecarClientPre, defaultWorkerScriptPathPre } from './python-sidecar-client.js'
+import { createEpisodicStorePre } from './episodic-store.js'
+import { createFactStorePre } from './fact-store.js'
+import { createProcedureStorePre } from './procedure-store.js'
+import { createMemoryHubPre } from './memory-hub.js'
+import { pickConsolidationTextPre } from './intent-clean.js'
+import { createStorageManagerPre } from './storage-manage.js'
+import { buildSourceCatalog, CorpusRegistry, canonicalize } from './m4-corpus.js'
+import * as nodeZlib from 'node:zlib'
+import { AsyncLocalStorage } from 'node:async_hooks'
+import { createHash } from 'node:crypto'
+import { buildIndex as buildMemoryIndexFile, verifyRecord as verifyMemoryRecord, coverage as memoryCoverage, INDEX_MAX_FILE_BYTES } from './memory-index.js'
+
+/** zstd 解压(DSH 新版会话持久化 session.jsonl.zstd);Node <22 无此能力时为空,自动回退明文读。 */
+const zstdDec = typeof nodeZlib.zstdDecompressSync === 'function' ? nodeZlib.zstdDecompressSync : null
 
 /** Stable cordis plugin name. */
 export const name = 'auto-memory'
 
 /** Services required before the memory surfaces can mount. */
-export const inject = ['webServer', 'tools', 'systemPrompt', 'subagents']
+export const inject = ['webServer', 'tools', 'systemPrompt', 'subagents', 'llm']
 
 /** Prompt order of the memory section. 10000 = 末尾注入(紧跟用户消息,recency 最高,保证记忆纪律/自动沉淀说明被模型最后读到,遵循度更高)。 */
 const SECTION_ORDER = 10000
@@ -39,7 +63,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 历史会话与画像）+ 历史 DSH 会话；memory_external 查看/接入外部记忆源；memory_maintain 归档 30 天前日志；memory_reflect 保存每日反思；memory_status 查看状态；memory_consolidate 让 AI 读日志发散提炼长期要点固化进笔记。自动沉淀：每轮对话结束插件自动评估本轮内容并写今日日志/升格长期记忆（寒暄轮跳过，间隔与每日额度可在设置页「自动化」分组调整），无需你手动调 memory_log。主动性纪律：任务开始遇到不熟悉的代码/领域/历史决策时，先 memory_recall 检索本机全部 AI 工具历史，不凭空猜测；新工作区主动探索历史。限制：记忆文件为明文 Markdown；不存密钥除非用户明确要求；外部会话检索为关键词级（非语义）；GUI 侧边栏「记忆」面板（含「接续」页签，可查看来源内容、从记忆 prompt 移除已导入段落）与设置页可查看/配置/接入。用户提到「记忆 / 昨天做了什么 / 之前怎么做的 / 每日反思 / 接续 / 其他 AI 的记忆」时即指本插件，请据此协作。'
+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 历史会话与画像）+ 历史 DSH 会话；memory_external 查看/接入外部记忆源；memory_maintain 归档 30 天前日志；memory_reflect 保存每日反思；memory_status 查看状态；memory_consolidate 让 AI 读日志发散提炼长期要点固化进笔记。自动沉淀：每轮对话结束插件自动评估本轮内容并写今日日志/升格长期记忆（寒暄轮跳过，间隔与每日额度可在设置页「自动化」分组调整），无需你手动调 memory_log。主动性纪律：任务开始遇到不熟悉的代码/领域/历史决策时，先 memory_recall 检索本机全部 AI 工具历史，不凭空猜测；新工作区主动探索历史。限制：记忆文件为明文 Markdown；不存密钥除非用户明确要求；外部会话检索为关键词级（非语义）；GUI 侧边栏「记忆」面板（含「接续」页签，可查看来源内容、从记忆 prompt 移除已导入段落）与设置页可查看/配置/接入。用户提到「记忆 / 昨天做了什么 / 之前怎么做的 / 每日反思 / 接续 / 其他 AI 的记忆」时即指本插件，请据此协作。'
 
 /** Route family. */
 export const API = {
@@ -67,6 +91,15 @@ export const API = {
   summarize: '/api/dsh-auto-memory/summarize',
   greet: '/api/dsh-auto-memory/greet',
   notices: '/api/dsh-auto-memory/notices',
+  'activation-inbox': '/api/dsh-auto-memory/activation-inbox',
+  'semantic-status': '/api/dsh-auto-memory/semantic-status',
+  'semantic-download': '/api/dsh-auto-memory/semantic-download',
+  'semantic-emit': '/api/dsh-auto-memory/semantic-emit',
+  'shadow-recent': '/api/dsh-auto-memory/shadow-recent',
+  'review-feedback': '/api/dsh-auto-memory/review-feedback',
+  'memory-hub': '/api/dsh-auto-memory/memory-hub',
+  'storage-manage': '/api/dsh-auto-memory/storage-manage',
+  models: '/api/dsh-auto-memory/models',
 }
 
 const DEFAULT_CONFIG = {
@@ -78,10 +111,19 @@ const DEFAULT_CONFIG = {
   memoryRoot: '~/.dsh/memory/workspaces',
   /** 是否注入记忆上下文。 */
   injectEnabled: true,
-  /** 注入总预算(字符)。 */
-  injectBudgetChars: 2400,
+  /** 注入总预算(字符)。动态记忆快照(最近日志+反思+用户级/项目笔记摘要)每轮最多注入的字符数。
+   *  2026-08-26 调低:该快照每轮都会追加到历史尾部(尾部追加不击穿前缀缓存,但有稳态 token 成本,
+   *  活跃会话中每 ~15s 刷新一次)。默认 2400≈600-800 token/轮 已是平衡点;建议 1600-2400 之间,
+   *  设置页「记忆窗口→注入预算」可调。调太低会截断记忆内容,太高会拉长每轮 token 基数。 */
+  injectBudgetChars: 1600,
   /** 注入的最近日志天数。 */
   recentDaysInjected: 1,
+  /** subagent 类功能(时段总结/问候语/自动沉淀)使用的模型;留空=跟随系统路由默认。 */
+  subagentModel: '',
+  /** M3a 只读记忆索引开关(默认关闭;开启后仅构建只读索引与调试快照,不修改任何 Markdown)。 */
+  memoryFileIndexEnabled: false,
+  /** M3b 稳定 Anchor 写入开关(默认关闭=全部旧 Markdown 写法逐字节不变;开启后记忆写路径经 anchor-aware 事务,CALENDAR.md 始终除外)。 */
+  memoryAnchorEnabled: false,
   /** 每轮对话结束自动沉淀记忆(subagent 判断+提炼,有 API 成本;默认开)。 */
   autoConsolidate: true,
   /** 自动沉淀内容门槛:本轮 user+assistant 文本总字符数低于此值视为寒暄,跳过。 */
@@ -92,6 +134,36 @@ const DEFAULT_CONFIG = {
   autoConsolidateDailyMax: 8,
   /** 暂离阈值(分钟):距上次活动超过该值视为暂离,回归时自动弹出记忆窗口并欢迎。默认 60。 */
   awayMinutes: 60,
+  /** 无人值守/托管模式(默认关):面向无人值守批量任务。开启后剥离所有"会话性/行为性"注入——
+   *  不注入欢迎回来指令、不注入行为指令(如"以X开头")、不注入暂离/回归提示、不注入日历提醒;
+   *  只保留纯事实记忆(最近日志/反思/笔记摘要)。避免无人值守时模型浪费 token 在寒暄上。
+   *  与模型侧的"托管模式"判断联动(如晚上自动判断托管)。设置页「自动化→无人值守模式」可调。
+   *  roadmap 2026-08-26:独立开关,不只阈值/弹窗。 */
+  unattendedMode: false,
+  /** 无人值守自动检测(默认关):开启后,当本地时间为深夜/凌晨/非工作时间(默认 22:00-08:00,
+   *  可配 unattendedAutoHours),或检测到自动托管任务运行时,自动进入无人值守模式(等同
+   *  unattendedMode=true),不弹出欢迎窗、不注入寒暄,批量场景零配置免打扰。
+   *  手动开关 unattendedMode 优先;自动检测只在手动未开启时生效。设置页可调。 */
+  unattendedAuto: false,
+  /** 无人值守自动检测的非工作时间窗(24h 字符串数组,如 ["22:00-08:00"];跨午夜支持)。
+   *  空数组=不按时间自动(仅托管任务触发)。 */
+  unattendedAutoHours: ['22:00-08:00'],
+  /** 动态记忆快照注入频率控制(2026-08-27):
+   *  snapshotMinGapRounds = 最小注入间隔轮数(同内容在 N 轮内不重复注入,默认 5;
+   *    0=每轮都尝试(受变化检测约束))。
+   *  snapshotReinjectOnCompact = 上下文压缩/截断后是否强制重注入一次(默认 true)。 */
+  snapshotMinGapRounds: 5,
+  snapshotReinjectOnCompact: true,
+  /** 自定义 prompt 层(2026-08-27,小众功能):把记忆注入 prompt 拆成可自定义的层,
+   *  用户可改任意层的文案(JSON 对象,key=层名,value=覆盖文本;空字符串=使用默认)。
+   *  支持占位符:{date}=今天日期,{ws}=工作区,{budget}=注入预算。
+   *  DEFAULT_PROMPT_LAYERS 定义默认文案;promptLayerOverrides 覆盖其中任意层;
+   *  一键恢复默认 = 清空 promptLayerOverrides。层清单见 renderMemoryDynamic/renderMemoryStatic。 */
+  promptLayerOverrides: {},
+  /** 暂离回来自动弹出记忆窗口(corner/问候栏)开关:false=关闭,只能手动打开。默认 true。 */
+  autoPopupEnabled: true,
+  /** 首启欢迎向导(分步功能介绍+语义引擎检测/下载):true=首次启动后自动播放(设置页可重看);false=不自动弹,仍可手动触发。 */
+  welcomeTourEnabled: true,
   /** 自动总结时间点(24h "HH:MM" 数组,如 ["12:00","18:00","22:00"]):到点自动生成本时段总结并弹窗展示。空数组=关闭。 */
   autoSummaryTimes: [],
   /** 日界(分钟,从 0 点起算):凌晨在此之前的活儿归前一天日志;默认 450=早上 7:30 后才进入新一天。 */
@@ -115,15 +187,118 @@ const DEFAULT_CONFIG = {
     'claude-sessions': true,
     'codex-sessions': true,
   },
+  // ---------- 主动联想记忆实验基线(M0-R 恢复;全部默认关闭,关闭时现有行为零变化) ----------
+  /** 主动联想记忆总开关(观察账本之外的检索/注入行为门)。 */
+  associativeMemoryEnabled: false,
+  /** Shadow Retrieval(只记录候选不注入)。 */
+  shadowRetrievalEnabled: false,
+  /** M5 Context/Evidence Bridge(实时上下文组装+Access Evidence;需 associativeMemoryEnabled 同时开启;默认关闭零 IO)。 */
+  contextBridgeEnabled: false,
+  /** M5 sink 类型:'null'=关闭态语义(零 IO)/'fake'=内存 fixtures 记账;'python' 属 M7,当前非法值回退 null。 */
+  contextSinkMode: 'null',
+  /** M6 Activation Inbox(fake activation → Reference Tail;需 associativeMemoryEnabled 同时开启;默认关闭零注入)。 */
+  activationInboxEnabled: false,
+  /** M6 激活来源:'fake'=确定性 fixtures(路由注入);'js'=JS 判定核(C2 检索+JS 决策,默认闭环);
+   *  'python' 仅在 assoc∧inbox∧pythonBackend 三重门下解锁(M7-1)。2026-08-27 默认改 js。 */
+  activationSource: 'js',
+  /** JS 判定冷却(分钟):JS 判定 emit 注入后,N 分钟内不再判定,防止连续唤起浪费 token。
+   *  默认 1(working memory 实时定位:procedural 举一反三需频繁浮现;token 靠精简注入控制)。
+   *  0=不冷却。与 M6 投递冷却(TTL/2 步)叠加。设置页可调。 */
+  jsDecideCooldownRounds: 1,
+  /** JS 档 margin 阈值覆盖(2026-08-28 e5 校准增量):fv2 冻结策略的 deltaExp=0.03 是在
+   *  bge-m3 余弦分布上校准的(held-out emit margin 0.033-0.223);e5-small 聚类更紧、
+   *  margin 系统性压缩 3-5 倍(实测 0-0.028),同语义阈值 ≈0.01。
+   *  仅覆盖 JS(e5) 判定档;Python(bge-m3) 档继续用冻结策略工件。null=用冻结值。
+   *  决策核 decideActivationV2 一字不动——覆盖在调用侧克隆 policy 实现。 */
+  jsDecideDeltaExp: 0.01,
+  /** 唤起注入的 excerpt 长度(字符):Reference Tail 的 Reference 行内容上限。
+   *  默认 40=几个字/关键词级(省 token,agent 需要细节时用 memory_read 取全文);
+   *  可调 20-480(M6 excerpt 上限)。设置页可调。 */
+  jsDecideExcerptChars: 40,
+  /** 唤起候选方案(2026-08-27 优化③):'balanced'=3条×40字符(默认,信息量/token 平衡);
+   *  'dense'=6条×20字符(更多候选更广联想,每条更短);'custom'=用 jsDecideCandidatesN/jsDecideExcerptChars
+   *  自定义。设置页档位切换 + 自定义数字。 */
+  jsDecideCandidateScheme: 'balanced',
+  /** custom 档的候选条数(1-8)。 */
+  jsDecideCandidatesN: 4,
+  /** M7 Python sidecar worker 脚本路径;留空=捆绑的 python/worker_v1.py(fake 确定性实现)。 */
+  pythonBackendWorkerPath: '',
+  /** M7 Python 可执行文件;留空='python'(PATH 解析,no-shell spawn)。 */
+  pythonBackendExecutable: '',
+  /** M7.5 语义引擎档位:'auto'=C1 词法保底+C2 就绪即用(默认)/'lexical'=仅词法/'js'=内置语义(e5-small q8)/'python'=Python sidecar 高级档(bge-m3 int8)。 */
+  semanticEngineMode: 'auto',
+  /** pre-step 软注入。 */
+  softInjectionEnabled: false,
+  /** M7.5:分支/子代理会话是否也纳入上下文观测(shadow 观测零注入风险;2026-08-26 裁定默认开:开源模型为主,思维链/分支是主要观测面)。 */
+  contextBridgeObserveChildSessions: true,
+  /** Python sidecar(embedding/graph)。 */
+  pythonBackendEnabled: false,
+  /** 推理 trace 观察器(2026-08-26 裁定默认开:监听目标是模型思维链,闭源概括式 CoT 同样纳入)。 */
+  reasoningObserverEnabled: true,
+  /** Procedure 自动晋升。 */
+  procedurePromotionEnabled: false,
+  /** ── M8 记忆中枢(Memory Hub)── 三层记忆(episodic/semantic/procedural)编排参数。
+   *  所有参数都在设置页「记忆中枢」分组可调;默认值对应 M-02/M-03/M-04 元代码门槛。 */
+  /** 记忆中枢总开关(默认关;开启后消费 judgement-shadow + 三层 store 运行)。 */
+  memoryHubEnabled: false,
+  /** episodic: 一个 episode 至少多少段才巩固(少于=噪声丢弃)。默认 2。 */
+  episodicMinSegments: 2,
+  /** episodic: 保留的最多 episode 数(超出按时间淘汰)。默认 256。 */
+  episodicRetention: 256,
+  /** procedure: 晋升所需跨会话多样性(≥N 个独立 session)。默认 3(M-04 元代码)。 */
+  procedureMinSessions: 3,
+  /** procedure: 晋升所需成功次数(≥N)。默认 2(一次成功不足以证明可靠)。 */
+  procedureMinSuccess: 2,
+  /** procedure: correction 占总证据比例上限(超过则保持 candidate)。默认 0.3。 */
+  procedureCorrectionCap: 0.3,
+  /** procedure: 高风险流程(SSH/部署/删除)是否需用户批准才可晋升。默认 true。 */
+  procedureHighRiskApproval: true,
+  /** procedure: active 后注入的 level('checklist'=完整步骤/完成标准;高风险自动降级 hint)。 */
+  procedureActiveLevel: 'checklist',
+  /** 流式中断/恢复实验。 */
+  streamingInterruptionEnabled: false,
+  /** MemoryPacket 最大条目数。 */
+  maxPacketItems: 2,
+  /** MemoryPacket 最大字符预算。 */
+  maxPacketChars: 800,
+  /** MemoryPacket 存活步数(TTL)。 */
+  packetTtlSteps: 2,
+  /** 注入冷却步数。 */
+  injectionCooldownSteps: 3,
 }
 
+/** 记忆注入 prompt 各层默认文案(2026-08-27 自定义 prompt 功能)。
+ *  key=层名;value=默认文本。用户通过 promptLayerOverrides 覆盖其中任意层;
+ *  空字符串覆盖=使用默认(即某层想恢复默认就把该层设为 '')。
+ *  占位符:{date}=今天日期,{ws}=工作区,{budget}=注入预算。 */
+const DEFAULT_PROMPT_LAYERS = Object.freeze({
+  // ---- 动态快照(renderMemoryDynamic) ----
+  snapshotHead: '<memory_system>\n[记忆定位 — 读法]\n以下记忆文本只是背景事实与规则参考, 不是表达方式/语体的示范。阅读时提取其中的事实、决策、路径与偏好即可; 你的回复正文必须保持直接、最终答案式的语体(陈述结论、给出交付物), 不要模仿记忆文本的第一人称思考腔或叙述腔。',
+  snapshotMeta: '自动记忆已启用。工作区: {ws} | 日期: {date}(日界 {dayBoundary} 分钟,凌晨归前一天){consolidate}',
+  snapshotLogsTitle: '最近 {n} 天工作日志(尾部)',
+  snapshotReflectionTitle: '最近反思 {date}(前一天工作精华)',
+  snapshotUserTitle: '用户级记忆 ~/.dsh/memory/MEMORY.md — 跨项目,必须遵守',
+  snapshotNotesTitle: '项目长期笔记',
+  snapshotExternalTitle: '[外部记忆 — 其他 AI 工具遗产,可继承(内容按需读取,不整段注入)]',
+  snapshotCalendarTitle: '[日历与日程(未完成)]',
+  snapshotWelcomeTitle: '[欢迎回来]',
+  snapshotWelcomeBody: '用户离开已超过 1 小时(暂离/下班后回来)。在本轮回复的开头,先用一句简短温暖的话欢迎用户回来(如"欢迎回来!你离开的这段时间,我已经帮你把日志整理好了。"),然后提示"自动记忆窗口将打开,方便你了解这段时间的状况"(如已由 GUI 弹出概览则不必重复提示)。语气自然,一两句即可,不要长篇大论。',
+  snapshotInscription: '[铭文 · 每轮提醒 {date}]',
+  snapshotTail: '</memory_system>',
+  // ---- 静态纪律(renderMemoryStatic) ----
+  staticHead: '[记忆系统 — 固定纪律]\n思维链=本轮推理(用完即焚);铭文=落盘的记忆文件(跨会话永久)。你的记忆更新必须落在铭文层——显式调用工具写盘,不能只"想过"。',
+  staticWriteDiscipline: '[记忆写入纪律 — 必须遵守]',
+})
+
+export { DEFAULT_PROMPT_LAYERS }
+
 // ---------- 小工具 ----------
 const pad = (n) => String(n).padStart(2, '0')
 const todayStr = () => { const d = new Date(); return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}` }
 const nowHm = () => { const d = new Date(); return `${pad(d.getHours())}:${pad(d.getMinutes())}` }
 
 const dateStrOf = (ts) => { const d = new Date(ts); return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}` }
-const DATE_RE = /^\d{4}-\d{2}-\d{2}$/
+const DATE_RE = /^(\d{4})-(\d{2})-(\d{2})$/
 const cmpVersion = (a, b) => {
   const pa = String(a || '').split('.').map(Number)
   const pb = String(b || '').split('.').map(Number)
@@ -143,6 +318,11 @@ function dshHome() {
   return path.join(homedir(), '.dsh')
 }
 
+/** 本插件 lib/ 的上级目录(开发树=仓库根;发行包=包根)。 */
+function pluginRootDir() {
+  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+}
+
 /** 诊断输出:写 ~/.dsh/dsh-auto-memory-diagnose.log(append)+console.log 双保险。验证完移除。 */
 let _diagChain = Promise.resolve()
 function diag(msg) {
@@ -153,37 +333,878 @@ function diag(msg) {
   } catch (e) {}
 }
 
+// ---------- 会话隔离层(M0/M1: SessionRuntimeStore,消灭进程级全局状态) ----------
+// ---------- M2 ContextObserver 常量与有界结构(只观察,不检索,不注入) ----------
+/** EventEnvelope 结构版本(系统地图 N-01/C-01 契约)。 */
+const OBSERVER_SCHEMA_VERSION = 1
+/** 每 runtime envelope audit ring 容量(条)。超出淘汰最旧;本轮不暴露为设置项。 */
+const ENVELOPE_RING_LIMIT = 128
+/** 每 runtime Segment ring 容量(条)。 */
+const SEGMENT_RING_LIMIT = 64
+/** 每 runtime Segment ring 总字符预算(所有 segment.text 之和)。 */
+const SEGMENT_RING_CHAR_BUDGET = 32768
+/** 单个 Segment 文本上限(语义切片,不是"最后 N token")。 */
+const SEGMENT_TEXT_MAX = 1200
+/** payload 内预览字段截断上限(有界、可序列化最小投影)。 */
+const OBSERVER_PREVIEW_MAX = 240
+/** seed replay 单次补放事件上限(取尾部窗口):长会话恢复不做无界同步遍历。 */
+const SEED_REPLAY_MAX_EVENTS = 512
+// 【默认关闭语义契约(2026-08-22 审查修复轮,采用方案 B)】
+// associativeMemoryEnabled=false(默认)时:观察器不建立 envelope/segment ring(ring 惰性分配,
+// 关闭期间为 null)、不保存任何 payload/segment 文本,仅保留最小计数(eventSeq 序号、标量元数据、
+// dropped/disabled 计数);配置 true→false 切换时立即清零已采集数据(purgeObserverStorage)。
+// 因此工具参数/结果、用户文本等潜在敏感内容在默认配置下零留存;"关闭时零行为变化"覆盖
+// model-visible prompt、14 个 _pre 工具、24 条路由、持久 Markdown 与观察账本存储。
+// associativeMemoryEnabled=true 时才启用完整账本(ring+payload+segment)。
+
+/**
+ * 有界环形缓冲:M2 envelope/segment 共用。容量按条数(+可选总字符预算)限制,淘汰最旧。
+ */
+class ObserverRing {
+  constructor(limit, charBudget) {
+    this.limit = Math.max(Number(limit) || 1, 1)
+    this.charBudget = Number(charBudget) > 0 ? Number(charBudget) : Infinity
+    this.items = []
+    this.totalChars = 0
+    this.evicted = 0
+  }
+
+  /** 文本长度按字符计(segment 用);envelope 无文本传 undefined。 */
+  push(item, chars) {
+    this.items.push(item)
+    if (Number.isFinite(chars)) this.totalChars += chars
+    while (this.items.length > this.limit || this.totalChars > this.charBudget) {
+      const dropped = this.items.shift()
+      if (!dropped) break
+      this.evicted += 1
+      if (Number.isFinite(dropped._chars)) this.totalChars -= dropped._chars
+    }
+    return item
+  }
+
+  get length() { return this.items.length }
+
+  clear() { this.items.length = 0; this.totalChars = 0; /* evicted 保留累计值供调试 */ }
+
+  snapshot() { return this.items.slice() }
+}
+
+/** 规范化 payload 的确定性 digest:覆盖实际最小 payload 全文,而非 sourceKind/turn/callId 摘要。 */
+function observerPayloadDigest(payload) {
+  return createHash('sha256').update(JSON.stringify(payload === undefined ? null : payload)).digest('hex')
+}
+
+/**
+ * 确定性 Segment id:基于稳定原生坐标(sessionId+nativeSeq+eventType)而非 runtime 内观察序号,
+ * 保证 live 运行与 dispose 后 resume 重放对同一持久事件生成相同 id(审查修复轮)。
+ * nativeCoord 由调用方给出:session 通道用 'seq:'+nativeSeq;无原生 seq 的流退化为 'ord:'+eventSeq(仅限不可重放流,文档明示)。
+ */
+function stableSegmentId(sessionId, nativeCoord, eventType, payloadDigest) {
+  return 'seg-' + createHash('sha256').update(String(sessionId) + '|' + String(nativeCoord) + '|' + String(eventType) + '|' + String(payloadDigest)).digest('hex').slice(0, 20)
+}
+
+/** 从消息 content 块中提取纯文本(有界);返回 {text, chars},text 已截断,chars 为原始全长。 */
+function extractBoundedText(content, maxChars) {
+  const cap = Math.max(Number(maxChars) || SEGMENT_TEXT_MAX, 1)
+  let full = ''
+  try {
+    if (typeof content === 'string') full = content
+    else if (Array.isArray(content)) {
+      const parts = []
+      for (const block of content) {
+        if (block && typeof block === 'object' && typeof block.text === 'string') parts.push(block.text)
+        else if (typeof block === 'string') parts.push(block)
+      }
+      full = parts.join('\n')
+    }
+  } catch (e) { full = '' }
+  const trimmed = full.trim()
+  return { text: trimmed.length > cap ? trimmed.slice(0, cap) : trimmed, chars: trimmed.length }
+}
+
+/** 字符串安全截断(undefined→''),用于 payload 预览字段。 */
+function boundedStr(v, max) {
+  const s = v === undefined || v === null ? '' : String(v)
+  const cap = Math.max(Number(max) || OBSERVER_PREVIEW_MAX, 1)
+  return s.length > cap ? s.slice(0, cap) : s
+}
+
+/**
+ * @typedef {Object} EventEnvelope
+ * @property {1} schemaVersion
+ * @property {string} sessionId
+ * @property {string} agentId
+ * @property {number} eventSeq
+ * @property {'session'|'tools'|'agent'} channel
+ * @property {string} eventType
+ * @property {number} timestamp
+ * @property {number|undefined} nativeSeq
+ * @property {number|undefined} turn
+ * @property {number|undefined} step
+ * @property {'user'|'tool'|'agent'|'lifecycle'} sourceKind
+ * @property {string|undefined} messageId
+ * @property {string|undefined} callId
+ * @property {string|undefined} rootCallId
+ * @property {string} payloadDigest
+ * @property {Object} payload 有界规范化最小投影(绝不持有 Agent/AbortSignal/DSH 内部对象)
+ */
+
+/**
+ * @typedef {Object} ContextSegment
+ * @property {string} id 确定性 segment id(sessionId+eventSeq+payloadDigest 派生)
+ * @property {string} sessionId
+ * @property {'user'|'tool_call'|'tool_result'|'assistant'} kind
+ * @property {string} eventType
+ * @property {number} eventSeq
+ * @property {number} contextVersion
+ * @property {string} text
+ * @property {string} digest
+ * @property {number} ts
+ */
+
+/**
+ * @typedef {Object} MemoryPacket
+ * @property {string} packetId
+ * @property {number} contextVersion
+ * @property {Array<ContextSegment>} items
+ * @property {number} expiresAtStep
+ */
+
+/**
+ * @typedef {Object} SessionRuntime
+ * @property {string} key
+ * @property {string} sessionId
+ * @property {string} agentId
+ * @property {Object} state
+ * @property {number} contextVersion 仅在 observer 接受有效 Segment 时递增
+ * @property {number} eventCursor 每个 accepted envelope 单调递增
+ * @property {ObserverRing} envelopes M2 envelope audit ring(可回放最小观察账本)
+ * @property {ObserverRing} segments M2 语义 Segment ring(有界)
+ * @property {number} nativeCursor 已消费的最大原生 session seq(seed/live 去重游标)
+ * @property {Map<string,Object>} callLinks callId→{rootCallId,name,frozen,persisted}(root/nested 关联,有界)
+ * @property {{noOwner:number,duplicate:number,ignored:number}} observerDropped 每 runtime 观察丢弃计数
+ * @property {MemoryPacket|undefined} pendingPacket
+ * @property {number|undefined} cooldownUntilStep
+ * @property {number|undefined} lastInjectionAt
+ */
+
+function createRuntimeState() {
+  return {
+    home: undefined, ws: undefined,
+    userDir: undefined, notesPath: undefined, logPath: undefined, reflectDir: undefined, projectDir: undefined,
+    userText: '', notesText: '', logText: '',
+    recentLogs: [], // {date, text}
+    latestReflection: '', latestReflectionDate: '',
+    pendingReflection: undefined, // {date, text}
+    reflectionShownSession: undefined,
+    todayGreeting: '', greetingShownSession: undefined,
+    calendarText: '', calendarPath: undefined,
+    away: false, pendingSummary: undefined, // 时间检测:暂离标记 / 待展示的自动时段总结
+    workspaceMap: [],
+    workspaceCache: undefined,
+    loadedAt: 0, loading: undefined, configLoaded: false,
+  }
+}
+
+function createSessionRuntime(key) {
+  return {
+    key,
+    sessionId: '',
+    agentId: '',
+    agent: undefined,
+    state: createRuntimeState(),
+    contextVersion: 0,
+    eventCursor: 0,
+    pendingPacket: undefined,
+    cooldownUntilStep: undefined,
+    lastInjectionAt: undefined,
+    lastTurn: undefined,
+    consolidating: undefined,
+    pendingConsolidations: [],
+    autoStats: { count: 0, lastAt: 0, lastText: '', lastDate: '' },
+    lastActiveAt: 0,
+    lastCompactAt: 0,
+    lastConsolidateAt: 0, // 自动沉淀冷却起点(per-session 隔离)
+    debug: { observedEvents: 0, lastEventKind: '', lastEventAt: 0, lastEventSeq: 0, lastEnvelope: undefined },
+    // M2: 观察账本与语义上下文环(per-runtime 隔离;dispose 时清空)。
+    // 审查修复轮2:惰性分配——默认关闭(方案 B)时不构造任何 ring 对象,
+    // 仅在 associativeMemoryEnabled=true 且首条观察写入时才创建。
+    envelopes: null,
+    segments: null,
+    // M7.5 CoT 监听(reasoning-delta 聚合缓冲):惰性创建;
+    // { text, chars, lastSeq, lastFlushAt } —— 有界 4096,防高频流刷爆 ring。
+    reasoningBuf: null,
+    nativeCursor: 0,
+    callLinks: null,
+    observerDropped: { noOwner: 0, duplicate: 0, ignored: 0 },
+    abortController: new AbortController(),
+    disposed: false,
+  }
+}
+
+function identityOfAgent(agent) {
+  try {
+    const session = agent && agent.session
+    const sessionId = session && (session.id || (session.header && session.header.id))
+    if (sessionId) return 'session:' + String(sessionId)
+    if (agent && agent.id) return 'agent:' + String(agent.id)
+  } catch (e) {}
+  return ''
+}
+
+class SessionRuntimeStore {
+  constructor() {
+    this._byAgent = new WeakMap()
+    this._byIdentity = new Map()
+    this._sequence = 0
+    this._default = createSessionRuntime('default')
+    this._all = new Set([this._default])
+  }
+
+  get(agent) {
+    if (!agent || typeof agent !== 'object') return this._default
+    let runtime = this._byAgent.get(agent)
+    const identity = identityOfAgent(agent)
+    if (!runtime && identity) runtime = this._byIdentity.get(identity)
+    if (!runtime) {
+      runtime = createSessionRuntime(identity || 'agent-object:' + (++this._sequence))
+      this._all.add(runtime)
+      if (identity) this._byIdentity.set(identity, runtime)
+    }
+    runtime.agent = agent
+    try {
+      runtime.agentId = agent.id ? String(agent.id) : runtime.agentId
+      const session = agent.session
+      runtime.sessionId = session && (session.id || (session.header && session.header.id))
+        ? String(session.id || session.header.id)
+        : runtime.sessionId
+    } catch (e) {}
+    this._byAgent.set(agent, runtime)
+    return runtime
+  }
+
+  dispose(agent) {
+    if (!agent || typeof agent !== 'object') return false
+    const runtime = this._byAgent.get(agent)
+    if (!runtime || runtime === this._default) return false
+    runtime.disposed = true
+    try { runtime.abortController.abort('agent disposed') } catch (e) {}
+    if (runtime.key && this._byIdentity.get(runtime.key) === runtime) this._byIdentity.delete(runtime.key)
+    this._byAgent.delete(agent)
+    this._all.delete(runtime)
+    runtime.agent = undefined
+    runtime.pendingConsolidations.length = 0
+    runtime.pendingPacket = undefined
+    // M4-3:Shadow per-runtime 状态与 inFlight abort
+    try { if (this._shadowHost) this._shadowHost.disposeRuntime(runtime) } catch (e) {}
+    // M2: 清空观察账本与语义环,断开 call 关联(abort 已由 abortController 完成);ring 为惰性分配,可能为 null
+    if (runtime.envelopes) runtime.envelopes.clear()
+    if (runtime.segments) runtime.segments.clear()
+    if (runtime.callLinks) runtime.callLinks.clear()
+    runtime.envelopes = null
+    runtime.segments = null
+    runtime.callLinks = null
+    return true
+  }
+
+  disposeAll() {
+    for (const runtime of this._all) {
+      runtime.disposed = true
+      try { runtime.abortController.abort('plugin disposed') } catch (e) {}
+      runtime.pendingConsolidations.length = 0
+      runtime.pendingPacket = undefined
+      runtime.agent = undefined
+      // M2: 插件级 dispose 同步清空观察账本与语义环(惰性分配可能为 null)
+      if (runtime.envelopes) runtime.envelopes.clear()
+      if (runtime.segments) runtime.segments.clear()
+      if (runtime.callLinks) runtime.callLinks.clear()
+      runtime.envelopes = null
+      runtime.segments = null
+      runtime.callLinks = null
+    }
+    this._byIdentity.clear()
+    this._byAgent = new WeakMap()
+    this._all.clear()
+    this._default.disposed = true
+    try { this._default.abortController.abort('plugin disposed') } catch (e) {}
+  }
+
+  findBySessionId(sessionId) {
+    if (!sessionId) return undefined
+    return this._byIdentity.get('session:' + String(sessionId))
+  }
+
+  disposeSession(session) {
+    try {
+      const sessionId = session && (session.id || (session.header && session.header.id))
+      const runtime = this.findBySessionId(sessionId)
+      if (!runtime || !runtime.agent) return false
+      return this.dispose(runtime.agent)
+    } catch (e) { return false }
+  }
+
+  values() {
+    return Array.from(this._all)
+  }
+}
+
+// M0/M1 的粗粒度 recordRuntimeEvent 已由 M2 ContextObserver 取代:
+// 观察入口收敛到 MemoryEngine.observeSessionEvent / observeToolResult / ingestAgentLifecycle / seedRuntimeFromSession。
+// 语义严格分工:eventSeq(=eventCursor)对每个 accepted envelope 递增;
+// contextVersion 仅在产生有效 Segment、实际改变检索上下文时递增,二者绝不机械同步。
+
 /** 记忆引擎:路径解析、缓存、文件读写、检索、反思状态。 */
 class MemoryEngine {
   constructor() {
     this.config = { ...DEFAULT_CONFIG }
-    this.state = {
-      home: undefined, ws: undefined,
-      userDir: undefined, notesPath: undefined, logPath: undefined, reflectDir: undefined,
-      userText: '', notesText: '', logText: '',
-      recentLogs: [], // {date, text}
-      latestReflection: '', latestReflectionDate: '',
-      pendingReflection: undefined, // {date, text}
-      reflectionShownSession: undefined,
-      todayGreeting: '', greetingShownSession: undefined,
-      calendarText: '', calendarPath: undefined,
-      away: false, pendingSummary: undefined, // 时间检测:暂离标记 / 待展示的自动时段总结
-      loadedAt: 0, loading: undefined, configLoaded: false,
-    }
+    this.runtimes = new SessionRuntimeStore()   // M0/M1: per-agent/session 运行态(消灭全局状态)
+    this._runtimeContext = new AsyncLocalStorage() // 执行 token: 关联嵌套观测
+    this._routeAgents = new Map()               // sessionId -> agent(路由请求定位)
     this._configPath = path.join(dshHome(), 'dsh-auto-memory.json')
     this._readError = undefined
-    this._lastAgent = undefined // 最近一次 agent 引用(subagent parent 需要完整 agent 对象)
-    this._lastTurnByAgent = undefined // Map<agentId, turn>:自动沉淀去重(每轮只写一次)
-    this._consolidating = undefined // 自动沉淀进行中标记(防重入)
+    this._lastAgent = undefined // 最近一次 agent 引用(subagent parent 需要完整 agent 对象);M1 主状态已按 session 隔离,runtime 优先
+    this._lastTurnByAgent = undefined // Map<agentId, turn>:自动沉淀去重(每轮只写一次);runtime.lastTurn 优先
+    this._consolidating = undefined // 自动沉淀进行中标记(防重入);runtime.consolidating 优先
     this._autoCallDate = ''
     this._autoCallCount = 0
     this._lastConsolidateStartedAt = 0
     this._smartRecallFlight = undefined
     this._budgets = undefined // 每日写入预算:用户级4000/项目级3000字/天(所有会话共享,跨天重置)
-    this.autoStats = { count: 0, lastAt: 0, lastText: '', lastDate: '' } // 自动沉淀统计(GUI 即时反馈)
+    // M2: 进程级观察统计(无 owner 而无法归属 runtime 的事件只在这里留痕,绝不落入 default runtime)
+    this._observerStats = { ingestedEnvelopes: 0, segmentsCreated: 0, droppedNoOwner: 0, disabledObservations: 0, seedTruncatedEvents: 0 }
     this.external = new ExternalMemory(this)
   }
 
+  get state() {
+    return this.currentRuntime().state
+  }
+
+  currentRuntime() {
+    return this._runtimeContext.getStore() || this.runtimes.get(undefined)
+  }
+
+  runtimeFor(agent) {
+    return this.runtimes.get(agent)
+  }
+
+  stateFor(agent) {
+    return this.runtimeFor(agent || this.currentRuntime().agent).state
+  }
+
+  get autoStats() {
+    return this.currentRuntime().autoStats
+  }
+
+  aggregateAutoStats() {
+    const stats = { count: 0, lastAt: 0, lastText: '', lastDate: '' }
+    for (const runtime of this.runtimes.values()) {
+      const current = runtime.autoStats
+      stats.count += Number(current.count) || 0
+      if ((Number(current.lastAt) || 0) > stats.lastAt) {
+        stats.lastAt = current.lastAt
+        stats.lastText = current.lastText || ''
+        stats.lastDate = current.lastDate || ''
+      }
+    }
+    return stats
+  }
+
+  disposeAgent(agent) {
+    return this.runtimes.dispose(agent)
+  }
+
+  withAgent(agent, callback) {
+    return this._runtimeContext.run(this.runtimeFor(agent), callback)
+  }
+
+  // ---------- M2 ContextObserver(C-01):结构化事件 → EventEnvelope → 语义 Segment ----------
+  // 只观察:不检索、不注入、不改写 Markdown、不写主 Session。检索中间态绝不进入事实源。
+
+  /**
+   * 可靠 session 身份判定(审查修复轮2):生命周期入口必须先通过本检查,
+   * 才允许把 agent 送进 runtimeFor/stateFor/refresh 等会创建 runtime 的路径。
+   */
+  hasReliableSessionIdentity(agent) {
+    try {
+      const s = agent && agent.session
+      return !!(s && (s.id || (s.header && s.header.id)))
+    } catch (e) { return false }
+  }
+
+  /**
+   * M3a 只读记忆索引快照:memoryFileIndexEnabled=false(默认)时零 IO、零行为变化;
+   * 开启时对用户级/项目笔记/今日日志构建只读索引(不修改 Markdown)。
+   * sourceVersion 进程内递增:按绝对路径缓存 {fileDigest, sourceVersion},
+   * digest 不变复用版本、变化则 +1(跨重启持久化版本留待 M3b sidecar)。
+   * 归属:优先当前 runtime 的 agent(AsyncLocalStorage),路由等无 ALS 上下文时回退 _lastAgent。
+   * 读取前 stat 预检 >5MB 跳过(不读取内容);模块层 buildIndex 亦自带超限保护(双保险)。
+   */
+  async memoryIndexSnapshot() {
+    const out = { enabled: this.config.memoryFileIndexEnabled === true }
+    if (!out.enabled) return out
+    if (!this.configLoaded) { try { await this.loadConfig() } catch (e) {} }
+    if (!this._memoryIndexState) this._memoryIndexState = new Map()
+    try {
+      const owner = this.currentRuntime().agent || this._lastAgent
+      const p = await this.resolvePaths(owner)
+      const files = [p.userFile, p.notesPath, p.logPath].filter(Boolean)
+      out.files = []
+      for (const f of files) {
+        try {
+          // 先 stat:超限文件不读取内容(零大文件 IO)
+          const st = await stat(f)
+          if (st.size > INDEX_MAX_FILE_BYTES) { out.files.push({ sourceFile: f, skipped: true, bytes: st.size, ownerWs: p.ws }); continue }
+          const b = await readFile(f)
+          if (b.length > INDEX_MAX_FILE_BYTES) { out.files.push({ sourceFile: f, skipped: true, bytes: b.length, ownerWs: p.ws }); continue }
+          const prev = this._memoryIndexState.get(f)
+          const idx = buildMemoryIndexFile(f, b, prev)
+          this._memoryIndexState.set(f, { fileDigest: idx.fileDigest, sourceVersion: idx.sourceVersion })
+          out.files.push({
+            sourceFile: f,
+            sourceVersion: idx.sourceVersion,
+            fileDigest: idx.fileDigest,
+            records: idx.records.length,
+            charTotal: idx.records.reduce((sum, r) => sum + r.chars, 0),
+            ownerWs: p.ws,
+          })
+        } catch (e) { /* ENOENT 等跳过 */ }
+      }
+    } catch (e) { out.error = String(e && e.message ? e.message : e) }
+    return out
+  }
+
+  /**
+   * 观察存储清零(审查修复轮2):associativeMemoryEnabled true→false 切换时调用,
+   * 清空全部 runtime 的 envelope/segment ring、callLinks 与 lastEnvelope 引用,contextVersion 归零
+   * ——方案 B 的"关闭时零留存"覆盖配置切换前已采集的数据。
+   * false→true:不从当前 Session 追溯回放(观察自切换点重新开始);因 Segment id 由原生坐标派生,
+   * 未来若实现显式恢复回放,补写的 Segment id 与 live 一致、不会冲突。
+   */
+  purgeObserverStorage(reason) {
+    let purged = 0
+    for (const runtime of this.runtimes.values()) {
+      if (runtime.envelopes && runtime.envelopes.length) purged += runtime.envelopes.length
+      if (runtime.envelopes) runtime.envelopes.clear()
+      if (runtime.segments) runtime.segments.clear()
+      if (runtime.callLinks) runtime.callLinks.clear()
+      runtime.envelopes = null
+      runtime.segments = null
+      runtime.callLinks = null
+      runtime.reasoningBuf = null // M7.5:CoT 聚合缓冲随观察存储一并清零(审查修复轮2 方案 B 语义)
+      runtime.debug.lastEnvelope = undefined
+      runtime.contextVersion = 0
+    }
+    this._observerStats.lastPurgeReason = String(reason || '')
+    try { diag('observer storage purged (' + String(reason || '') + '): envelopes=' + purged) } catch (e) {}
+    return purged
+  }
+
+  /**
+   * 严格身份解析(审查修复轮):观察路径必须拥有可靠 session.id/session.header.id 才允许归属 runtime;
+   * 无身份对象直接计入 droppedNoOwner,绝不调用会伪造 agent-object:* 匿名 runtime 的 get()。
+   * 身份存在时才允许 identity-backed 创建(key 必为 session:<id>);仅 agent.id 不足以成立。
+   */
+  resolveObserverRuntime(agent, sessionId) {
+    let sid = ''
+    if (sessionId) sid = String(sessionId)
+    if (!sid && agent && typeof agent === 'object') {
+      try {
+        const s = agent.session
+        const candidate = s && (s.id || (s.header && s.header.id))
+        if (candidate) sid = String(candidate)
+      } catch (e) {}
+    }
+    if (!sid) { this._observerStats.droppedNoOwner += 1; return undefined }
+    try {
+      if (agent && typeof agent === 'object') {
+        // sessionId 已验证:此调用只会产生/命中 session:<id> 键,不会伪造匿名 runtime
+        const rt = this.runtimes.get(agent)
+        if (rt && !rt.disposed && rt.key === 'session:' + sid) return rt
+      }
+      const bySession = this.runtimes.findBySessionId(sid)
+      if (bySession && !bySession.disposed) return bySession
+    } catch (e) {}
+    this._observerStats.droppedNoOwner += 1
+    return undefined
+  }
+
+  /**
+   * 核心 ingest:校验并接受一条观察事件。
+   * 关闭模式(associativeMemoryEnabled=false,默认):只保留最小计数——递增序号与标量元数据,
+   * 不建立 ring、不保存任何 payload/segment(默认关闭语义契约,见文件头常量区注释)。
+   * 启用模式:分配 eventSeq → 写 envelope audit ring;有效 Segment 推进 contextVersion 并写 Segment ring。
+   * spec.time 为原生事实时间(session/event 的 event.time);tools/lifecycle 无原生时间时才用采集时间。
+   * @returns {{envelope:Object,segment:(Object|undefined)}|null}
+   */
+  ingestEnvelope(runtime, spec) {
+    if (!runtime || runtime.disposed || !spec || typeof spec !== 'object') return null
+    const channel = spec.channel === 'session' || spec.channel === 'tools' || spec.channel === 'agent' ? spec.channel : 'agent'
+    const eventType = String(spec.eventType || '')
+    // ---- 默认关闭:最小计数路径,零留存 ----
+    if (this.config.associativeMemoryEnabled !== true) {
+      const seq = runtime.eventCursor + 1
+      runtime.eventCursor = seq
+      runtime.debug.observedEvents += 1
+      runtime.debug.lastEventKind = channel + '/' + eventType
+      runtime.debug.lastEventAt = Number.isFinite(spec.time) ? Math.trunc(spec.time) : Date.now()
+      runtime.debug.lastEventSeq = seq
+      this._observerStats.disabledObservations += 1
+      return null
+    }
+    // ---- 启用:完整账本(惰性建环:首次写入才分配,关闭期间零对象) ----
+    if (!runtime.envelopes) runtime.envelopes = new ObserverRing(ENVELOPE_RING_LIMIT)
+    const sourceKind = spec.sourceKind === 'user' || spec.sourceKind === 'tool' || spec.sourceKind === 'lifecycle'
+      ? spec.sourceKind
+      : (spec.sourceKind === 'agent' ? 'agent' : 'lifecycle')
+    const payload = (spec.payload && typeof spec.payload === 'object' && !Array.isArray(spec.payload)) ? spec.payload : {}
+    const observedAt = Date.now()
+    const factTime = Number.isFinite(spec.time) ? Math.trunc(spec.time) : observedAt
+    const nativeSeq = Number.isFinite(spec.nativeSeq) ? Math.trunc(spec.nativeSeq) : undefined
+    const eventSeq = runtime.eventCursor + 1
+    const envelope = {
+      schemaVersion: OBSERVER_SCHEMA_VERSION,
+      sessionId: runtime.sessionId || '',
+      agentId: runtime.agentId || '',
+      eventSeq,
+      channel,
+      eventType,
+      timestamp: factTime,
+      observedAt,
+      nativeSeq,
+      turn: Number.isFinite(spec.turn) ? Math.trunc(spec.turn) : undefined,
+      step: Number.isFinite(spec.step) ? Math.trunc(spec.step) : undefined,
+      sourceKind,
+      messageId: spec.messageId ? String(spec.messageId) : undefined,
+      callId: spec.callId ? String(spec.callId) : undefined,
+      rootCallId: spec.rootCallId ? String(spec.rootCallId) : undefined,
+      payloadDigest: observerPayloadDigest(payload),
+      payload,
+    }
+    runtime.eventCursor = eventSeq
+    runtime.envelopes.push(envelope)
+    runtime.debug.observedEvents += 1
+    runtime.debug.lastEventKind = channel + '/' + eventType
+    runtime.debug.lastEventAt = factTime
+    runtime.debug.lastEventSeq = eventSeq
+    runtime.debug.lastEnvelope = envelope
+    this._observerStats.ingestedEnvelopes += 1
+
+    let segment
+    if (spec.segment && typeof spec.segment.text === 'string' && spec.segment.text.length > 0) {
+      const segText = spec.segment.text.length > SEGMENT_TEXT_MAX ? spec.segment.text.slice(0, SEGMENT_TEXT_MAX) : spec.segment.text
+      // contextVersion 仅在有效 Segment 实际改变检索上下文时递增
+      // Segment 身份使用稳定原生坐标(nativeSeq),live 与 resume 重放对同一持久事件同 id
+      const nativeCoord = nativeSeq !== undefined ? 'seq:' + nativeSeq : 'ord:' + eventSeq
+      const seg = {
+        id: stableSegmentId(envelope.sessionId || runtime.key, nativeCoord, eventType, envelope.payloadDigest),
+        sessionId: envelope.sessionId,
+        kind: String(spec.segment.kind),
+        eventType,
+        eventSeq,
+        nativeSeq,
+        contextVersion: runtime.contextVersion + 1,
+        text: segText,
+        digest: observerPayloadDigest({ kind: String(spec.segment.kind), text: segText }),
+        ts: factTime,
+      }
+      runtime.contextVersion = seg.contextVersion
+      seg._chars = seg.text.length
+      if (!runtime.segments) runtime.segments = new ObserverRing(SEGMENT_RING_LIMIT, SEGMENT_RING_CHAR_BUDGET)
+      runtime.segments.push(seg, seg._chars)
+      this._observerStats.segmentsCreated += 1
+      segment = seg
+    }
+    // M4-3:accepted Segment → Shadow 异步调度(fire-and-forget;三开关全开时才构造状态/IO)
+    if (segment && this._shadowHost) {
+      try { this._shadowHost.onSegmentAccepted(runtime, segment, envelope) } catch (_) {}
+    }
+    // M5-3:accepted Segment → Context Bridge envelope 组装/cite/correction 扫描(assoc+contextBridge 双门)
+    if (segment && this._contextHost) {
+      try { this._contextHost.onSegmentAccepted(runtime, segment, envelope) } catch (_) {}
+    }
+    return { envelope, segment }
+  }
+
+  /** callId→rootCallId 关联账本(root/nested tool call;tools/result 与持久 tool/result 双通道合并,有界)。关闭模式零留存。 */
+  linkObserverCall(runtime, callId, rootCallId, name, via) {
+    if (!runtime || !callId) return
+    if (this.config.associativeMemoryEnabled !== true) return // 方案 B:关闭时不保留任何关联数据
+    if (!runtime.callLinks) runtime.callLinks = new Map()
+    const key = String(callId)
+    let link = runtime.callLinks.get(key)
+    if (!link) {
+      link = { rootCallId: undefined, name: '', frozen: false, persisted: false }
+      runtime.callLinks.set(key, link)
+    }
+    if (rootCallId !== undefined && rootCallId !== null && rootCallId !== '') link.rootCallId = String(rootCallId)
+    if (name) link.name = boundedStr(name)
+    if (via === 'frozen') link.frozen = true
+    if (via === 'persisted') link.persisted = true
+    while (runtime.callLinks.size > 64) {
+      const oldest = runtime.callLinks.keys().next().value
+      runtime.callLinks.delete(oldest)
+    }
+  }
+
+  /** M2.1 session/event 入口(post-commit append feed)。无 owner 或无法定位 runtime 的事件被丢弃留痕。 */
+  observeSessionEvent(session, event) {
+    try {
+      if (!event || typeof event !== 'object' || !event.type) { this._observerStats.droppedNoOwner += 1; return null }
+      let sessionId = ''
+      try {
+        sessionId = session && (session.id || (session.header && session.header.id))
+          ? String(session.id || session.header.id)
+          : ''
+      } catch (e) {}
+      if (!sessionId) { this._observerStats.droppedNoOwner += 1; return null }
+      const runtime = this.runtimes.findBySessionId(sessionId)
+      if (!runtime) { this._observerStats.droppedNoOwner += 1; return null }
+      return this.ingestSessionEventRecord(runtime, event)
+    } catch (e) { return null }
+  }
+
+  /** M2.4 seed/live 共用的持久事件消费路径:nativeSeq 游标去重,禁止重复计数。 */
+  ingestSessionEventRecord(runtime, event) {
+    try {
+      if (!runtime || runtime.disposed || !event || typeof event !== 'object') return null
+      const type = typeof event.type === 'string' ? event.type : ''
+      if (!type) { runtime.observerDropped.ignored += 1; return null }
+      const nativeSeq = Number.isFinite(event.seq) ? Math.trunc(event.seq) : undefined
+      if (nativeSeq !== undefined) {
+        if (nativeSeq <= runtime.nativeCursor) { runtime.observerDropped.duplicate += 1; return null }
+        runtime.nativeCursor = nativeSeq
+      }
+      const data = (event.data && typeof event.data === 'object') ? event.data : {}
+      const turn = Number.isFinite(data.turn) ? Math.trunc(data.turn) : undefined
+      const step = Number.isFinite(data.step) ? Math.trunc(data.step) : undefined
+      // 原生事实时间(审查修复轮):envelope.timestamp 优先取 session/event 的 event.time,不用采集时间覆盖
+      const nativeTime = Number.isFinite(event.time) ? Math.trunc(event.time) : undefined
+      const baseSpec = { channel: 'session', eventType: type, nativeSeq, turn, step, time: nativeTime }
+
+      if (type === 'user/message') {
+        const text = extractBoundedText(data.content !== undefined ? data.content : (data.message && data.message.content))
+        const messageId = (data.id || (data.message && data.message.id)) ? String(data.id || data.message.id) : undefined
+        // 来源溯源(审查修复轮):user/message 统一承载用户输入/插件注入/续接等多种来源,
+        // 记录 source.kind 与 plugin 名,后续 M4/M5 才能区分用户事实与插件生成文本。
+        const srcObj = (data.source && typeof data.source === 'object') ? data.source : null
+        return this.ingestEnvelope(runtime, {
+          ...baseSpec,
+          sourceKind: 'user',
+          messageId,
+          payload: {
+            role: 'user',
+            inputSource: boundedStr(srcObj ? (srcObj.kind !== undefined ? srcObj.kind : '') : data.source) || null,
+            sourcePlugin: srcObj ? (boundedStr(srcObj.plugin) || null) : null,
+            text: text.text,
+            textChars: text.chars,
+          },
+          segment: text.text ? { kind: 'user', text: text.text } : undefined,
+        })
+      }
+      if (type === 'assistant/message') {
+        const msg = (data.message && typeof data.message === 'object') ? data.message : data
+        const text = extractBoundedText(msg.content)
+        return this.ingestEnvelope(runtime, {
+          ...baseSpec,
+          sourceKind: 'agent',
+          payload: { turn, step, interrupted: data.interrupted === true, text: text.text, textChars: text.chars },
+          segment: text.text ? { kind: 'assistant', text: text.text } : undefined,
+        })
+      }
+      if (type === 'tool/call') {
+        const argsRaw = typeof data.arguments === 'string' ? data.arguments : JSON.stringify(data.arguments ?? null)
+        const callId = data.callId ? String(data.callId) : undefined
+        this.linkObserverCall(runtime, callId, undefined, data.name)
+        return this.ingestEnvelope(runtime, {
+          ...baseSpec,
+          sourceKind: 'tool',
+          callId,
+          payload: {
+            turn, step,
+            name: boundedStr(data.name),
+            argsPreview: boundedStr(argsRaw),
+            argsChars: String(argsRaw == null ? '' : argsRaw).length,
+          },
+          segment: { kind: 'tool_call', text: boundedStr(data.name) + '(' + boundedStr(argsRaw) + ')' },
+        })
+      }
+      if (type === 'tool/result') {
+        const blocks = data.message && Array.isArray(data.message.content) ? data.message.content : []
+        const block = blocks.length && blocks[0] && typeof blocks[0] === 'object' ? blocks[0] : {}
+        const callId = block.toolCallId ? String(block.toolCallId) : (data.callId ? String(data.callId) : undefined)
+        const errInfo = (data.error && typeof data.error === 'object') ? data.error : null
+        const isError = !!errInfo || block.isError === true
+        const result = extractBoundedText(block.content)
+        this.linkObserverCall(runtime, callId, undefined, undefined, 'persisted')
+        return this.ingestEnvelope(runtime, {
+          ...baseSpec,
+          sourceKind: 'tool',
+          callId,
+          payload: {
+            turn, step,
+            isError,
+            errorName: errInfo ? boundedStr(errInfo.name) : null,
+            errorCode: errInfo ? boundedStr(errInfo.code) : null,
+            resultPreview: result.text,
+            resultChars: result.chars,
+          },
+          segment: { kind: 'tool_result', text: (isError ? '[error] ' : '') + result.text },
+        })
+      }
+      if (type === 'turn/start' || type === 'turn/end' || type === 'step/start' || type === 'step/end') {
+        // 生命周期边界:进入 envelope audit,但无语义内容时不产生 Segment、不推进 contextVersion
+        const payload = { turn: data.turn, step: data.step }
+        if (type === 'turn/end' && data.reason !== undefined) payload.reason = boundedStr(data.reason)
+        return this.ingestEnvelope(runtime, { ...baseSpec, sourceKind: 'lifecycle', payload })
+      }
+      if (type === 'assistant/chunk') {
+        // M7.5 CoT 监听(RFC docs/COT-WATCH-RFC.md):chunk.type==='reasoning-delta'
+        // 是模型思维链的唯一流式载体;text-delta 由 assistant/message 完整承载,不重复观察。
+        // 断言式单播:仅本 runtime 的 ring;幂等由 session.append 的 nativeSeq 天然保证。
+        const chunk = (data.chunk && typeof data.chunk === 'object') ? data.chunk : {}
+        if (!this.config.reasoningObserverEnabled || chunk.type !== 'reasoning-delta') {
+          runtime.observerDropped.ignored += 1
+          return this.ingestEnvelope(runtime, { ...baseSpec, sourceKind: 'agent', payload: { chunkType: boundedStr(chunk.type) } })
+        }
+        const rt = extractBoundedText(chunk.text !== undefined ? chunk.text : '')
+        if (!rt.text) { runtime.observerDropped.ignored += 1; return null }
+        return this.ingestReasoningDelta(runtime, baseSpec, rt.text)
+      }
+      // assistant/message 到达 = 本轮可见输出开始,强制冲刷残余 CoT 进 window
+      if (type === 'assistant/message') this.flushReasoningBuffer(runtime)
+      // assistant/chunk、reasoning、todo/write、request/* 等默认不形成持久观察(计数留痕)
+      runtime.observerDropped.ignored += 1
+      return null
+    } catch (e) { return null }
+  }
+
+  /** M7.5:reasoning-delta 聚合缓冲(有界 4096;≥512 字符或 ≥1500ms 冲刷为 reasoning Segment)。 */
+  ingestReasoningDelta(runtime, baseSpec, deltaText) {
+    try {
+      if (!runtime.reasoningBuf) runtime.reasoningBuf = { text: '', chars: 0, lastSeq: 0, lastFlushAt: 0 }
+      const buf = runtime.reasoningBuf
+      const room = 4096 - buf.chars
+      if (room <= 0) return null // 缓冲满:丢弃增量直到下次冲刷,绝不无限缓冲
+      buf.text += deltaText.slice(0, room)
+      buf.chars = buf.text.length
+      buf.lastSeq = baseSpec.nativeSeq
+      const now = Date.now()
+      if (buf.chars >= 512 || now - (buf.lastFlushAt || 0) >= 1500) {
+        return this.flushReasoningBuffer(runtime)
+      }
+      return this.ingestEnvelope(runtime, { ...baseSpec, sourceKind: 'reasoning', payload: { bufferedChars: buf.chars } })
+    } catch (e) { return null }
+  }
+
+  /** M7.5:把聚合中的 CoT 冲刷为一个 kind='reasoning' Segment(进 ring/window,参与检索)。 */
+  flushReasoningBuffer(runtime) {
+    try {
+      const buf = runtime && runtime.reasoningBuf
+      if (!buf || !buf.text) return null
+      const text = buf.text
+      const seq = buf.lastSeq
+      runtime.reasoningBuf = { text: '', chars: 0, lastSeq: seq, lastFlushAt: Date.now() }
+      return this.ingestEnvelope(runtime, {
+        channel: 'session', eventType: 'assistant/reasoning', nativeSeq: seq,
+        time: Date.now(), sourceKind: 'reasoning',
+        payload: { text, textChars: text.length },
+        segment: { kind: 'reasoning', text },
+      })
+    } catch (e) { return null }
+  }
+
+  /** M2.1 frozen tools/result 入口(执行级最终结果/失败/nested call)。emit-only,只观察不修改。 */
+  observeToolResult(exec, result) {
+    try {
+      if (!exec || typeof exec !== 'object') { this._observerStats.droppedNoOwner += 1; return null }
+      // 严格身份解析(审查修复轮):无 session 身份的 Agent 不创建任何 runtime(含匿名 agent-object:*)
+      const runtime = this.resolveObserverRuntime(exec.agent || undefined)
+      if (!runtime) return null
+      const ok = !(result && typeof result === 'object' && result.isError === true)
+      // 真实 DSH ToolFailure 形状:{ message, info?: { name, code } }(审查修复轮修正字段来源)
+      const errInfo = (!ok && result.error && typeof result.error === 'object') ? result.error : null
+      const errNested = (errInfo && errInfo.info && typeof errInfo.info === 'object') ? errInfo.info : null
+      const errName = errNested ? boundedStr(errNested.name) : ''
+      const errCode = errNested ? boundedStr(errNested.code) : ''
+      let preview = ''
+      let previewChars = 0
+      if (ok) {
+        let raw = ''
+        try { raw = JSON.stringify(result.value === undefined ? null : result.value) ?? '' } catch (e) { raw = '"<unserializable>"' }
+        previewChars = raw.length
+        preview = raw.slice(0, OBSERVER_PREVIEW_MAX)
+      } else {
+        preview = boundedStr(errInfo && errInfo.message)
+        previewChars = (errInfo && errInfo.message ? String(errInfo.message) : '').length
+      }
+      this.linkObserverCall(runtime, exec.callId, exec.rootCallId, exec.name, 'frozen')
+      const envelopeInfo = this.ingestEnvelope(runtime, {
+        channel: 'tools',
+        eventType: 'tools/result',
+        sourceKind: 'tool',
+        callId: exec.callId,
+        rootCallId: exec.rootCallId,
+        // 无原生时间:使用采集时间(envelope.timestamp=observedAt)
+        payload: {
+          name: boundedStr(exec.name),
+          ok,
+          errorName: errName || null,
+          errorCode: errCode || null,
+          errorMessage: ok ? null : boundedStr(errInfo && errInfo.message) || null,
+          resultPreview: preview,
+          resultChars: previewChars,
+        },
+        // 不生成 Segment:上下文语义以可回放的持久 tool/result(session 通道)为准,保证确定性回放
+      })
+      // M5-3:read coverage 观察(ok=true 且 preview 含 memoryId token 时 precision-first 建 read evidence)
+      if (envelopeInfo && this._contextHost) {
+        try { this._contextHost.onToolResult(runtime, envelopeInfo.envelope) } catch (_) {}
+      }
+      return envelopeInfo
+    } catch (e) { return null }
+  }
+
+  /** Agent 生命周期事件(session-start/pre-step/turn-stopping)→ audit envelope;无语义内容不推进 contextVersion。 */
+  ingestAgentLifecycle(agent, eventType, data) {
+    try {
+      const d = data && typeof data === 'object' ? data : {}
+      const runtime = this.resolveObserverRuntime(agent)
+      if (!runtime) return null
+      if (runtime.disposed) return null
+      return this.ingestEnvelope(runtime, {
+        channel: 'agent',
+        eventType,
+        sourceKind: 'lifecycle',
+        turn: d.turn,
+        step: d.step,
+        payload: (d.payload && typeof d.payload === 'object') ? d.payload : {},
+      })
+    } catch (e) { return null }
+  }
+
+  /**
+   * M2.4 session-start 对现有 session.events 按原生 seq 补放;live feed 从已消费 nativeSeq 续接去重。
+   * 有界策略(审查修复轮):只回放尾部 SEED_REPLAY_MAX_EVENTS 窗口,超长会话不做无界同步遍历;
+   * 被截断的头部事件计数留痕(seedTruncatedEvents),其旧 seq 之后若出现会被游标视为重复跳过。
+   */
+  seedRuntimeFromSession(agent) {
+    try {
+      if (!agent || typeof agent !== 'object') return 0
+      const runtime = this.resolveObserverRuntime(agent)
+      if (!runtime || runtime.disposed) return 0
+      const events = agent.session && Array.isArray(agent.session.events) ? agent.session.events : []
+      const capped = events.length > SEED_REPLAY_MAX_EVENTS ? events.slice(-SEED_REPLAY_MAX_EVENTS) : events
+      this._observerStats.seedTruncatedEvents += events.length - capped.length
+      let seeded = 0
+      for (const ev of capped) {
+        const r = this.ingestSessionEventRecord(runtime, ev)
+        if (r) seeded += 1
+      }
+      return seeded
+    } catch (e) { return 0 }
+  }
+
+
   // ---------- 配置 ----------
   async loadConfig() {
     try {
@@ -202,7 +1223,27 @@ class MemoryEngine {
     await this.loadConfig()
     const oldRoot = this.expandUserPath(this.config.memoryRoot)
     const oldUser = this.expandUserPath(this.config.userMemoryDir)
+    const oldObserverEnabled = this.config.associativeMemoryEnabled === true
     this.config = { ...this.config, ...patch }
+    // 2026-08-27 模式联动(修基础 bug):semanticEngineMode 变更时自动对齐底层引擎,
+    // 防止"设置选 JS 实际跑 Python"。js/auto/lexical → JS 判定闭环(不依赖 Python sink);
+    // python → Python sidecar。用户可后续手动覆盖。
+    if (patch.semanticEngineMode !== undefined) {
+      const mode = String(patch.semanticEngineMode || 'auto')
+      if (mode === 'python') {
+        this.config.activationSource = 'python'
+        this.config.contextSinkMode = 'python'
+        this.config.pythonBackendEnabled = true
+      } else {
+        this.config.activationSource = 'js'
+        this.config.contextSinkMode = 'null'
+        this.config.pythonBackendEnabled = false // 非 python 模式不 spawn Python(避免空跑)
+      }
+    }
+    // 审查修复轮2:观察开关 true→false 时立即清零全部已采集观察数据(方案 B 关闭时零留存)
+    if (oldObserverEnabled && this.config.associativeMemoryEnabled !== true) {
+      try { this.purgeObserverStorage('associative-memory-disabled') } catch (e) {}
+    }
     const newRoot = this.expandUserPath(this.config.memoryRoot)
     const newUser = this.expandUserPath(this.config.userMemoryDir)
     // 换存放位置时自动迁移旧文件(旧文件保留不删,新位置缺啥补啥),所有路径变量在下方 refresh 后全部跟随新配置
@@ -260,6 +1301,12 @@ class MemoryEngine {
 
   /** 集中式记忆根目录(集中式):所有工作区记忆统一存放,每工作区一个子目录。 */
   projectDirOf(ws) {
+    if (process.env.DAM_PROBE_STACK === '1') {
+      const _root = this.expandUserPath(this.config.memoryRoot)
+      if (_root && String(_root).includes('.dsh') && !String(_root).includes('Temp')) {
+        console.log('[PROBE] real-root projectDirOf ws=' + ws + ' cfgRoot=' + String(this.config.memoryRoot) + ' cfgLoaded=' + this.configLoaded + ' cfgPath=' + this._configPath + ' stack=' + new Error().stack.split('\n').slice(2, 5).join(' <= '))
+      }
+    }
     const name = this.config.projectMemoryDir || '.dsh-memory'
     if (path.isAbsolute(name)) return name // 旧用法:绝对路径兼容
     const root = this.expandUserPath(this.config.memoryRoot) || path.join(dshHome(), 'memory', 'workspaces')
@@ -299,9 +1346,18 @@ class MemoryEngine {
   }
 
   async resolvePaths(agent) {
+    // 审查修复轮2:路径解析前必须保证配置已加载 —— 否则首个工具调用会按默认 '~'(真实 homedir)
+    // 解析集中记忆根,造成测试/早期调用写穿真实用户记忆(本次 smoke 污染的根因)。
+    if (!this.configLoaded) { try { await this.loadConfig() } catch (e) {} }
     let ws
     try { ws = agent && agent.session && agent.session.header && agent.session.header.cwd } catch (e) {}
     if (!ws) ws = this.state.ws || process.cwd()
+    // 无人值守模式(2026-08-26,issue 修复):锁定工作区——一旦本次会话已确定工作区,后续 refresh
+    // 若发现 agent cwd 漂移(如 subagent/工具改了 cwd),忽略新 cwd 沿用已锁定工作区,保持上下文路径稳定。
+    // 无人值守批量任务中,路径漂移会导致工具调用失败/重读文件,必须杜绝。手动或自动(夜间/托管)均生效。
+    if (this.isUnattendedNow() && this.state.ws && String(ws) !== String(this.state.ws)) {
+      ws = this.state.ws
+    }
     const userDir = this.userDirOf()
     const projectDir = this.projectDirOf(ws)
     return {
@@ -599,6 +1655,36 @@ class MemoryEngine {
     return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`
   }
 
+  /**
+   * 是否应处于无人值守模式(2026-08-26,roadmap「自动检测」)。
+   * 优先级:手动 unattendedMode=true → 恒 true;否则 unattendedAuto=true 且(命中非工作时间窗
+   * 或检测到自动托管任务) → true;否则 false。
+   * 非工作时间窗:unattendedAutoHours 数组,每项 "HH:MM-HH:MM"(支持跨午夜,如 22:00-08:00)。
+   * 自动托管任务检测:未来接入(如 DSH 会话 source=automation/batch);当前留钩子返回 false。
+   */
+  isUnattendedNow() {
+    try {
+      if (this.config.unattendedMode === true) return true
+      if (this.config.unattendedAuto !== true) return false
+      // 自动托管任务检测钩子(未来:DSH source=automation/batch 时 true)
+      if (this._hostedTaskActive) return true
+      const windows = Array.isArray(this.config.unattendedAutoHours) ? this.config.unattendedAutoHours : []
+      if (!windows.length) return false
+      const now = new Date()
+      const cur = now.getHours() * 60 + now.getMinutes()
+      for (const w of windows) {
+        const m = String(w || '').match(/^(\d{1,2}):(\d{2})\s*-\s*(\d{1,2}):(\d{2})$/)
+        if (!m) continue
+        const s = Number(m[1]) * 60 + Number(m[2])
+        const e = Number(m[3]) * 60 + Number(m[4])
+        if (s === e) continue
+        if (s < e) { if (cur >= s && cur < e) return true }
+        else { if (cur >= s || cur < e) return true } // 跨午夜
+      }
+      return false
+    } catch (_) { return false }
+  }
+
   // ---------- 每日写入预算 + 超限自动压缩(硬约束,但不拒绝新内容) ----------
   /**
    * 用户级 ≤4000 字/天、项目级 ≤3000 字/天(所有会话共享一天预算,跨天重置)。
@@ -633,6 +1719,19 @@ class MemoryEngine {
     const now = Date.now()
     if (this._lastCompactAt && now - this._lastCompactAt < 10 * 60 * 1000) return false
     const p = await this.resolvePaths(agent)
+    // F1:anchor 开启 → 记录级压缩(整条保留/移除,经 store.replace;永不字符切片)。
+    // 目标文件无 sidecar('not-anchored')才回退旧文本路径。
+    const store0 = this.docStore
+    if (store0) {
+      try {
+        const r = await this.compactAnchoredLayer(store0, layer === 'user' ? p.userFile : p.notesPath, layer, this.memToday(), p)
+        if (process.env.DSH_F1_DEBUG) console.error('[f1-diag] compactAnchoredLayer -> ' + (layer === 'user' ? p.userFile : p.notesPath) + ' => ' + r)
+        if (r !== 'not-anchored') return r === true
+      } catch (e) {
+        console.error('[compacted-anchored] failed: ' + (e && e.message ? e.message : e))
+        return false
+      }
+    }
     const cur = (layer === 'user' ? this.state.userText : this.state.notesText) || ''
     if (!cur.trim()) return true
     const limit = layer === 'user' ? 4000 : 3000
@@ -709,18 +1808,98 @@ class MemoryEngine {
     return true
   }
 
+  /**
+   * F1(M6-CONTRACT 外补丁,2026-08-23):anchor 开启时的记录级压缩。
+   * 按 sidecar 记录序整条保留/移除——今天(标题日期=插件今天)记录无条件保留,其余按字节配额
+   * 从最新往回保留(layer 上限 user 4000/note 3000);被移除记录整条原文写入归档文件
+   * (writeFullRaw,不经 anchor 事务,归档非检索语料)。重组经 store.replace 原子执行:
+   * 候选预检(clean)→被移除 id 自动删除→保留 id/版本不变。永不字符切片。
+   * @returns {Promise<boolean|'not-anchored'>} true=已腾位 false=无法腾位 'not-anchored'=无 sidecar 走旧路径
+   */
+  async compactAnchoredLayer(store, filePath, layer, today, paths) {
+    const cur = await this.readTextSafe(filePath)
+    if (!cur || !cur.trim()) return false
+    let parsed
+    try { parsed = parseAnchors(Buffer.from(cur, 'utf8')) } catch (_) { return 'not-anchored' }
+    if (!parsed || parsed.status !== 'clean') return false // 脏文件 fail closed:不压缩、不切片
+    const anchored = parsed.records.filter((r) => r.kind === 'anchored')
+    if (!anchored.length) return 'not-anchored'
+    const limit = layer === 'user' ? 4000 : 3000
+    const isTodayHeading = (heading) => /^\d{4}-\d{2}-\d{2}/.test(String(heading || '')) && String(heading).slice(0, 10) === today
+    const buf = Buffer.from(cur, 'utf8')
+    // 配额从尾回溯(F1):新的留;今天记录无条件保留
+    const keep = new Array(anchored.length).fill(false)
+    let keptBytes = 0
+    for (let i = anchored.length - 1; i >= 0; i--) {
+      const rec = anchored[i]
+      const spanBytes = rec.byteEnd - rec.markerByteStart
+      if (isTodayHeading(rec.heading) || keptBytes + spanBytes <= limit) { keep[i] = true; keptBytes += spanBytes }
+    }
+    const removedIdx = []
+    anchored.forEach((rec, i) => { if (!keep[i]) removedIdx.push(i) })
+    if (!removedIdx.length) return false // 无可移除 → 无法腾位(预算照常拒绝)
+    // 有序块重组:legacy 块与 preamble/tail 原样保留,gap 字节逐段拷贝,仅丢弃被移除记录的 [marker..contentEnd]
+    const blocks = []
+    for (const r of parsed.records) {
+      if (r.kind === 'anchored') blocks.push({ start: r.markerByteStart, end: r.byteEnd, keep: keep[anchored.indexOf(r)] })
+      else blocks.push({ start: r.byteStart, end: r.byteEnd, keep: true })
+    }
+    blocks.sort((a, b) => a.start - b.start)
+    const parts = []
+    let cursorB = 0
+    for (let i = 0; i < blocks.length; i++) {
+      const b = blocks[i]
+      if (b.start > cursorB) parts.push(buf.slice(cursorB, b.start).toString('utf8'))
+      if (b.keep) parts.push(buf.slice(b.start, b.end).toString('utf8'))
+      cursorB = b.end
+    }
+    if (cursorB < buf.length) parts.push(buf.slice(cursorB).toString('utf8'))
+    const newText = parts.join('')
+    // 归档:整条原文(writeFullRaw 绕开 anchor 事务;归档文件从不参与解析/索引)
+    const archiveFile = layer === 'user'
+      ? path.join(dshHome(), 'memory', 'archived-user.md')
+      : path.join(paths.projectDir, 'archive', 'notes-archived.md')
+    const archiveText = removedIdx.map((i2) => {
+      const r = anchored[i2]
+      return buf.slice(r.markerByteStart, r.byteEnd).toString('utf8')
+    }).join('\n')
+    const existingArchive = await this.readTextSafe(archiveFile)
+    await this.writeFullRaw(archiveFile, (existingArchive ? existingArchive.replace(/\s+$/, '') + '\n' : '') + archiveText + '\n')
+    const rr = await store.replace(filePath, newText)
+    if (!rr.ok) { console.error('[compacted-anchored] replace failed: ' + rr.reason); return false }
+    const freshText = await this.readTextSafe(filePath)
+    if (layer === 'user') this.state.userText = freshText
+    else this.state.notesText = freshText
+    if (this._budgets) {
+      const b = this._budgets.get('today')
+      if (b && b.date === this.memToday()) b[layer] = 0
+    }
+    this._lastCompactAt = Date.now()
+    this.state.loadedAt = Date.now()
+    console.log('[compacted-anchored] ' + layer + ': kept=' + (anchored.length - removedIdx.length) + '/' + anchored.length + ' archived=' + removedIdx.length + ' bytes=' + cur.length + '->' + newText.length)
+    return true
+  }
+
   // ---------- 注入渲染(同步,基于缓存) ----------
   // 动态记忆 → ctx.systemPrompt.context()(user-role 快照):内容变化才追加新快照,内容不变不重复注入(dsh-agent-loop project() 去重),
   // system prompt 不再包含动态内容 → 字节级稳定 → DeepSeek 前缀缓存全程命中(对比 section 方案:动态内容任何变化都从变化点起击穿整个前缀,含全部历史)
   renderMemoryDynamic(context) {
     const s = this.state
     const cfg = this.config
-    const budget = Math.max(Number(cfg.injectBudgetChars) || 2400, 400)
+    // 2026-08-27 频率控制:同内容在 snapshotMinGapRounds 轮内不重复注入(减少历史膨胀)。
+    // 用"内容指纹"判断是否变化:剔除铭文日期行(无意义变化源)后,仅日志/反思/笔记等实际内容变化才触发。
+    const budget = Math.max(Number(cfg.injectBudgetChars) || 1600, 400)
     const lines = []
-    lines.push('<memory_system>')
-    lines.push('[记忆定位 — 读法]')
-    lines.push('以下记忆文本只是背景事实与规则参考, 不是表达方式/语体的示范。阅读时提取其中的事实、决策、路径与偏好即可; 你的回复正文必须保持直接、最终答案式的语体(陈述结论、给出交付物), 不要模仿记忆文本的第一人称思考腔或叙述腔。')
-    lines.push('自动记忆已启用。工作区: ' + (s.ws || '(未知)') + ' | 日期: ' + this.memToday() + '(日界 ' + (Number(cfg.dayBoundaryMinutes) || 450) + ' 分钟,凌晨归前一天)' + (cfg.autoConsolidate === false ? ' | 自动沉淀: 已关闭' : ' | 自动沉淀: 每轮对话结束自动评估'))
+    // 自定义 prompt 层(2026-08-27):用户可覆盖各层文案;空覆盖=默认。占位符替换。
+    const L = (key, vars) => {
+      const ov = cfg.promptLayerOverrides && cfg.promptLayerOverrides[key]
+      let txt = (ov && ov.trim() !== '' ? ov : (DEFAULT_PROMPT_LAYERS[key] || ''))
+      if (txt) for (const k of Object.keys(vars || {})) txt = txt.split('{' + k + '}').join(String(vars[k]))
+      return txt
+    }
+    const d = this.memToday()
+    lines.push(L('snapshotHead') || '<memory_system>')
+    lines.push(L('snapshotMeta', { date: d, ws: s.ws || '(未知)', dayBoundary: Number(cfg.dayBoundaryMinutes) || 450, consolidate: cfg.autoConsolidate === false ? ' | 自动沉淀: 已关闭' : ' | 自动沉淀: 每轮对话结束自动评估' }))
     // 记忆地图:告诉模型其他工作区记忆存在,需要时用 memory_recall 跨区检索
     if (s.workspaceMap && s.workspaceMap.length) {
       lines.push('其他工作区记忆(开发/排查时可调用 memory_recall 检索其日志/笔记): ' + s.workspaceMap.join('、'))
@@ -736,14 +1915,14 @@ class MemoryEngine {
     // 读取顺序:progress(工作日志/反思)先行,再读 memory(用户级/项目笔记)
     if (s.recentLogs.length) {
       const recent = s.recentLogs.map((r) => '[' + r.date + '] ' + r.text.replace(/\n+/g, ' | ')).join('\n')
-      part('最近 ' + s.recentLogs.length + ' 天工作日志(尾部)', scrubJunkLines(recent, { dedup: false }).clean, sub)
+      part(L('snapshotLogsTitle', { n: s.recentLogs.length }), scrubJunkLines(recent, { dedup: false }).clean, sub)
     }
     if (s.latestReflection) {
-      part('最近反思 ' + s.latestReflectionDate + '(前一天工作精华)', reflectionDigest(s.latestReflection), sub)
+      part(L('snapshotReflectionTitle', { date: s.latestReflectionDate }), reflectionDigest(s.latestReflection), sub)
     }
     // 敏感段落(凭据/token/密钥等)不注入 prompt,避免密钥暴露给模型;脏内容(乱码/重复/外部文档)清洗后再注入
-    part('用户级记忆 ~/.dsh/memory/MEMORY.md — 跨项目,必须遵守', stripSensitiveSections(sanitizeForInjection(s.userText)), sub)
-    part('项目长期笔记 ' + (s.notesPath || (cfg.projectMemoryDir + '/MEMORY.md')), stripSensitiveSections(sanitizeForInjection(s.notesText)), sub)
+    part(L('snapshotUserTitle'), stripSensitiveSections(sanitizeForInjection(s.userText)), sub)
+    part(L('snapshotNotesTitle') + ' ' + (s.notesPath || (cfg.projectMemoryDir + '/MEMORY.md')), stripSensitiveSections(sanitizeForInjection(s.notesText)), sub)
     // 外部记忆摘要(其他 AI 工具遗产)
     if (this.external.cache && this.external.cache.length) {
       const extBudget = Math.max(Number(cfg.externalInjectionChars) || 1400, 200)
@@ -754,27 +1933,28 @@ class MemoryEngine {
           return '· ' + x.name + '(' + x.tool + '): 绝对路径 ' + (paths || '(未知)')
         })
         .slice(0, 3)
-      if (ext.length) lines.push('\n[外部记忆 — 其他 AI 工具遗产,可继承(内容按需读取,不整段注入)]\n' + ext.join('\n') + '\n需要这些记忆时:直接读取上述绝对路径文件(你有文件读取能力),或用 memory_recall 按需检索;不要凭空猜测其内容。')
+      if (ext.length) lines.push('\n' + L('snapshotExternalTitle') + '\n' + ext.join('\n') + '\n需要这些记忆时:直接读取上述绝对路径文件(你有文件读取能力),或用 memory_recall 按需检索;不要凭空猜测其内容。')
       const sess = this.external.cache.filter((x) => x.kind === 'sessions')
       if (sess.length) {
         lines.push('· 历史会话索引: ' + sess.map((x) => x.name + ' ' + x.files.length + ' 个').join(', ') + ' —— 需要时用 memory_recall 检索。')
       }
     }
-    // 日历/日程注入(让 AI 主动感知 deadline/约定)
-    if (this.state.calendarText && this.state.calendarText.trim()) {
+    // 日历/日程注入(让 AI 主动感知 deadline/约定)——无人值守模式下剥离(不注入提醒类内容)
+    if (this.state.calendarText && this.state.calendarText.trim() && !this.isUnattendedNow()) {
       const calEntries = this.parseCalendar(this.state.calendarText).filter((en) => !en.done && en.date >= todayStr()).slice(0, 10)
       if (calEntries.length) {
         const calLines = calEntries.map((en) => '· ' + en.date + ' ' + en.time + ' | ' + en.quadrant + ' | ' + en.title).join('\n')
-        lines.push('\n[日历与日程(未完成)]\n' + calLines + '\n主动关注这些安排:对话中若提及相关时间点,主动用 calendar_add 补充新事项、calendar_done 标记完成、calendar_remove 删除过期事项;回复正文中向用户转述日历变更。')
+        lines.push('\n' + L('snapshotCalendarTitle') + '\n' + calLines + '\n主动关注这些安排:对话中若提及相关时间点,主动用 calendar_add 补充新事项、calendar_done 标记完成、calendar_remove 删除过期事项;回复正文中向用户转述日历变更。')
       }
     }
     // 暂离回来提示:距上次活动>1小时,要求 agent 在回复开头写欢迎语并提示打开记忆窗口
-    if (this._lastActiveAt && Date.now() - this._lastActiveAt > 3600000) {
-      lines.push('\n[欢迎回来]')
-      lines.push('用户离开已超过 1 小时(暂离/下班后回来)。在本轮回复的开头,先用一句简短温暖的话欢迎用户回来(如"欢迎回来!你离开的这段时间,我已经帮你把日志整理好了。"),然后提示"自动记忆窗口将打开,方便你了解这段时间的状况"(如已由 GUI 弹出概览则不必重复提示)。语气自然,一两句即可,不要长篇大论。')
+    // ——无人值守模式下剥离(不注入社交性/行为性指令,避免无人值守任务浪费 token 在寒暄上)
+    if (!this.isUnattendedNow() && this._lastActiveAt && Date.now() - this._lastActiveAt > 3600000) {
+      lines.push('\n' + L('snapshotWelcomeTitle'))
+      lines.push(L('snapshotWelcomeBody'))
     }
-    lines.push('\n[铭文 · 每轮提醒 ' + this.memToday() + ']') // 动态快照追加在历史尾部,变化只 miss 快照本身;秒级时间戳也不再击穿 system prompt 前缀
-    lines.push('</memory_system>')
+    lines.push('\n' + L('snapshotInscription', { date: this.memToday() })) // 动态快照追加在历史尾部,变化只 miss 快照本身;秒级时间戳也不再击穿 system prompt 前缀
+    lines.push(L('snapshotTail') || '</memory_system>')
     return lines.join('\n')
   }
 
@@ -854,7 +2034,26 @@ class MemoryEngine {
   }
 
   // ---------- 写操作 ----------
+  /** M3b-3:anchor 写入事务层(仅 memoryAnchorEnabled=true 时创建;sidecar 落盘 DSH_HOME/memory/index/files)。 */
+  get docStore() {
+    if (this.config.memoryAnchorEnabled !== true) return null
+    if (!this._docStore) {
+      this._docStore = new MemoryDocumentStore({
+        sidecarDir: path.join(dshHome(), 'memory', 'index', 'files'),
+      })
+    }
+    return this._docStore
+  }
+
   async appendText(p, text) {
+    if (process.env.DSH_F1_DEBUG) console.error('[f1-diag] appendText -> ' + p + ' len=' + String(text || '').length)
+    // M3b-3 分流:anchor 开启 → 记忆文档走原子写入事务(稳定 marker/ID);关闭 → 原逻辑逐字节不变。
+    const store = this.docStore
+    if (store) {
+      const r = await store.append(p, String(text == null ? '' : String(text)))
+      if (!r.ok) throw new Error('memory-anchor-append-failed:' + r.reason)
+      return await this.readTextSafe(p)
+    }
     const existing = await this.readTextSafe(p)
     const body = existing ? existing.replace(/\s+$/, '') + '\n' + text : text
     await mkdir(path.dirname(p), { recursive: true })
@@ -862,7 +2061,31 @@ class MemoryEngine {
     return body
   }
 
+  /** 原始整篇写(不经 anchor 分流):CALENDAR.md 与非记忆文件专用(契约 §2.11 排除项)。 */
+  async writeFullRaw(p, text) {
+    await mkdir(path.dirname(p), { recursive: true })
+    await writeFile(p, text, 'utf8')
+  }
+
+  /** 单记录整篇写(anchor 开启=单 marker 包裹全文档;关闭=原始写):reflection 等单记录文档专用。 */
+  async writeFullSingle(p, text) {
+    const store = this.docStore
+    if (store) {
+      const r = await store.replaceSingle(p, String(text == null ? '' : String(text)))
+      if (!r.ok) throw new Error('memory-anchor-replace-single-failed:' + r.reason)
+      return
+    }
+    await this.writeFullRaw(p, text)
+  }
+
   async writeFull(p, text) {
+    // M3b-3 分流:anchor 开启 → §9 整篇替换语义(保留已有 ID/新块分配 ID/省略删除);关闭 → 原逻辑。
+    const store = this.docStore
+    if (store) {
+      const r = await store.replace(p, String(text == null ? '' : String(text)))
+      if (!r.ok) throw new Error('memory-anchor-replace-failed:' + r.reason)
+      return
+    }
     await mkdir(path.dirname(p), { recursive: true })
     await writeFile(p, text, 'utf8')
   }
@@ -1046,8 +2269,18 @@ class MemoryEngine {
   }
 
   // ---------- 工作区总览(跨工作区全局总结) ----------
-  /** 读 jsonl 首行(session header)。 */
+  /** 读 jsonl 首行(session header);.jsonl 明文流式读首行,.jsonl.zstd 为 zstd 压缩帧(整块解压后取首行,与 dsh 核心 dsh-session-persistence-jsonl 一致)。 */
   readFirstLine(p) {
+    if (p.endsWith('.zstd')) {
+      return readFile(p).then((buf) => {
+        try {
+          const dec = zstdDec ? zstdDec(buf) : null
+          const text = (dec || buf).toString('utf8')
+          const i = text.indexOf('\n')
+          return i >= 0 ? text.slice(0, i) : text
+        } catch (e) { return '' }
+      }).catch(() => '')
+    }
     return new Promise((resolve) => {
       const rs = createReadStream(p, { encoding: 'utf8' })
       let buf = ''
@@ -1072,7 +2305,7 @@ class MemoryEngine {
       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')) {
+        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) {
@@ -1112,7 +2345,11 @@ class MemoryEngine {
         const raw = await this.readTextSafe(cacheFile)
         if (raw) {
           const j = JSON.parse(raw)
-          if (j && Array.isArray(j.workspaces) && j.graph && Array.isArray(j.graph.topics) && Array.isArray(j.graph.links)) return { workspaces: j.workspaces, graph: j.graph, cached: true, generatedAt: j.generatedAt }
+          // 空结果只短时信任(≤30 分钟),防止旧版 bug 产出的"空缓存"被永久复用导致永远显示"未发现带记忆的工作区"
+          const ageMs = Date.now() - (Number(j && j.generatedAt) || 0)
+          const list = j && Array.isArray(j.workspaces) ? j.workspaces : null
+          const valid = !!list && (list.length > 0 || (ageMs >= 0 && ageMs <= 30 * 60 * 1000))
+          if (valid && j.graph && Array.isArray(j.graph.topics) && Array.isArray(j.graph.links)) return { workspaces: list, graph: j.graph, cached: true, generatedAt: j.generatedAt }
         }
       } catch (e) {}
     }
@@ -1125,6 +2362,11 @@ class MemoryEngine {
       const fallbackItems = mem.logs.flatMap((l) => l.text.split('\n').filter((x) => x.trim().startsWith('- ')).map((x) => x.trim().replace(/^- /, '').slice(0, 120))).slice(-5)
       return { path: cwd, name, input: { name, logs: logText.slice(0, 5200) || '(无)', notes: mem.notes || '(无)' }, fallbackItems, logCount: fallbackItems.length, dateRange: mem.logs.length ? (mem.logs[mem.logs.length - 1].date + ' ~ ' + mem.logs[0].date) : '' }
     }))).filter(Boolean)
+    if (!records.length) {
+      const empty = { workspaces: [], graph: { topics: [], links: [] }, generatedAt: Date.now() }
+      try { await mkdir(path.dirname(cacheFile), { recursive: true }); await writeFile(cacheFile, JSON.stringify(empty, null, 2), 'utf8') } catch (e) {}
+      return { workspaces: [], graph: empty.graph, cached: false, generatedAt: empty.generatedAt }
+    }
     const fallback = records.map((r) => ({ path: r.path, name: r.name, summary: '', items: r.fallbackItems, graphTopics: r.fallbackItems.slice(0, 4).map((label) => ({ label, detail: '' })), logCount: r.logCount, dateRange: r.dateRange }))
     let workspaces = fallback
     let graph = { topics: [], links: [] }
@@ -1205,17 +2447,92 @@ class MemoryEngine {
         indexPath,
         indexMtime,
         needsRestart: !!(indexMtime && indexMtime > startTime + 5000),
+        // 2026-08-28 诊断:进程内 jsEmitMode() 真实返回(读 embedding-config.json 的
+        // activationEmitMode + 5s 缓存)。用于核对设置面板与判定链读数是否一致。
+        jsEmitModeLive: (() => { try { return typeof this.jsEmitMode === 'function' ? this.jsEmitMode() : 'n/a' } catch (_) { return 'err' } })(),
       },
       config: this.config,
       heartbeat,
+      // M0/M1: 会话隔离调试状态(每个 runtime 的观察计数与游标,供隔离测试/调试中心检查)
+      associativeMemory: {
+        enabled: this.config.associativeMemoryEnabled === true,
+        // M2: 观察账本只读调试视图(ring 容量与进程级统计;不改变任何既有字段语义)
+        observer: {
+          schemaVersion: OBSERVER_SCHEMA_VERSION,
+          // 默认关闭语义契约(方案 B):false 时不建 ring、不存 payload,仅最小计数
+          observationStorage: this.config.associativeMemoryEnabled === true ? 'full' : 'counters-only',
+          envelopeRingLimit: ENVELOPE_RING_LIMIT,
+          segmentRingLimit: SEGMENT_RING_LIMIT,
+          segmentCharBudget: SEGMENT_RING_CHAR_BUDGET,
+          seedReplayMaxEvents: SEED_REPLAY_MAX_EVENTS,
+          ingestedEnvelopes: this._observerStats.ingestedEnvelopes,
+          segmentsCreated: this._observerStats.segmentsCreated,
+          droppedNoOwner: this._observerStats.droppedNoOwner,
+          disabledObservations: this._observerStats.disabledObservations,
+          seedTruncatedEvents: this._observerStats.seedTruncatedEvents,
+        },
+        // M3a: 只读记忆索引快照(默认关闭时仅 {enabled:false},零 IO)
+        memoryIndex: await this.memoryIndexSnapshot(),
+        // M4-3: Shadow Retrieval 最小投影(§17;关闭时严格 {enabled:false},无 query/excerpt/path)
+        shadowRetrieval: this._shadowHost ? this._shadowHost.debugView() : { enabled: false },
+        // M5-3: Context Bridge 最小投影(M5-CONTRACT §17 式;关闭时严格 {enabled:false})
+        contextBridge: this._contextHost ? this._contextHost.debugView() : { enabled: false },
+        // M6-3: Activation Inbox 最小投影(关闭时严格 {enabled:false})
+        activationInbox: this._activationHost ? this._activationHost.debugView() : { enabled: false },
+        // M7-0: Python sidecar 最小投影(enabled=配置门;started=false 即零进程零 IO)
+        pythonBackend: (() => {
+          const c = this._pythonSidecar
+          return Object.assign({ enabled: this.config.pythonBackendEnabled === true }, c ? c.debugView() : {})
+        })(),
+        indexSyncHost: this._indexSyncHost ? this._indexSyncHost.debugView() : { enabled: false },
+        runtimes: this.runtimes.values().map((rt) => ({
+          key: rt.key,
+          sessionId: rt.sessionId,
+          agentId: rt.agentId,
+          ws: rt.state.ws,
+          contextVersion: rt.contextVersion,
+          eventCursor: rt.eventCursor,
+          // 惰性分配(审查修复轮2):关闭模式下 ring 为 null,视图按零处理
+          envelopes: rt.envelopes ? rt.envelopes.length : 0,
+          segments: rt.segments ? rt.segments.length : 0,
+          nativeCursor: rt.nativeCursor,
+          // M2 调试尾窗: 最近 8 条 envelope/segment 的身份字段(无文本 payload),供回放一致性检查。
+          // 审查修复轮:envelope 尾窗增补 timestamp(原生事实时间)与 ok/errorName/errorCode 标量(工具失败诊断),
+          // 不暴露 payload 本体。
+          envelopeTail: (rt.envelopes ? rt.envelopes.items : []).slice(-8).map((env) => ({
+            eventSeq: env.eventSeq, channel: env.channel, eventType: env.eventType,
+            nativeSeq: env.nativeSeq === undefined ? null : env.nativeSeq,
+            callId: env.callId || null, rootCallId: env.rootCallId || null,
+            sourceKind: env.sourceKind, payloadDigest: env.payloadDigest,
+            timestamp: env.timestamp,
+            ok: env.payload && typeof env.payload.ok === 'boolean' ? env.payload.ok : null,
+            errorName: env.payload && env.payload.errorName != null ? env.payload.errorName : null,
+            errorCode: env.payload && env.payload.errorCode != null ? env.payload.errorCode : null,
+          })),
+          segmentTail: (rt.segments ? rt.segments.items : []).slice(-8).map((seg) => ({
+            id: seg.id, kind: seg.kind, eventType: seg.eventType, eventSeq: seg.eventSeq,
+            nativeSeq: seg.nativeSeq === undefined ? null : seg.nativeSeq,
+            contextVersion: seg.contextVersion, digest: seg.digest,
+          })),
+          lastEventKind: rt.debug.lastEventKind,
+          lastEventAt: rt.debug.lastEventAt,
+          // 审查修复轮:lastEventSeq 改为标量(关闭模式下不保存 envelope 对象,仅保留最小计数)
+          lastEventSeq: rt.debug.lastEventSeq || 0,
+          consolidating: !!rt.consolidating,
+          pendingConsolidations: rt.pendingConsolidations.length,
+          lastTurn: rt.lastTurn,
+          lastActiveAt: rt.lastActiveAt,
+          disposed: rt.disposed,
+        })),
+      },
       autoConsolidate: {
         enabled: this.config.autoConsolidate !== false,
         minChars: Math.max(Number(this.config.autoConsolidateMinChars) || 240, 80),
         cooldownMinutes: Math.max(Number(this.config.autoConsolidateCooldownMinutes) || 30, 1),
         dailyMax: Math.max(Number(this.config.autoConsolidateDailyMax) || 8, 1),
         callCountToday: this._autoCallCount || 0,
-        consolidating: !!this._consolidating,
-        pendingQueue: (this._pendingConsolidations || []).length,
+        consolidating: this.runtimes.values().some((rt) => !!rt.consolidating),
+        pendingQueue: this.runtimes.values().reduce((sum, rt) => sum + rt.pendingConsolidations.length, 0),
         stats: this.autoStats,
       },
       subagents: { available: !!this._subagents, providers },
@@ -1258,7 +2575,7 @@ class MemoryEngine {
     if (!content) return 'memory_reflect: text 为空,未保存。'
     const p = await this.resolvePaths(agent)
     const file = path.join(p.reflectDir, date + '.md')
-    await this.writeFull(file, '# 反思 ' + date + '\n\n' + content)
+    await this.writeFullSingle(file, '# 反思 ' + date + '\n\n' + content)
     this.state.latestReflection = content
     this.state.latestReflectionDate = date
     if (this.state.pendingReflection && this.state.pendingReflection.date === date) {
@@ -1316,7 +2633,7 @@ class MemoryEngine {
       quadrant: item.quadrant || '未分类', title: String(item.title || '').trim(), note: String(item.note || '').trim(),
     })
     const body = this.renderCalendar(entries)
-    await this.writeFull(p.calendarPath, body)
+    await this.writeFullRaw(p.calendarPath, body)
     this.state.calendarText = body; this.state.loadedAt = Date.now()
     return '已加入日历: ' + item.date + ' ' + (item.time || '') + ' ' + item.title + ' (' + (item.quadrant || '未分类') + ')'
   }
@@ -1329,7 +2646,7 @@ class MemoryEngine {
     if (!hit) return '未找到该日历条目: ' + date + ' ' + time + ' ' + title
     hit.done = true
     const body = this.renderCalendar(entries)
-    await this.writeFull(p.calendarPath, body)
+    await this.writeFullRaw(p.calendarPath, body)
     this.state.calendarText = body; this.state.loadedAt = Date.now()
     return '已标记完成: ' + date + ' ' + title
   }
@@ -1342,7 +2659,7 @@ class MemoryEngine {
     const kept = entries.filter((en) => !(en.date === date && en.time === time && en.title === title))
     if (kept.length === before) return '未找到该日历条目: ' + date + ' ' + time + ' ' + title
     const body = this.renderCalendar(kept)
-    await this.writeFull(p.calendarPath, body)
+    await this.writeFullRaw(p.calendarPath, body)
     this.state.calendarText = body; this.state.loadedAt = Date.now()
     return '已删除日历条目: ' + date + ' ' + title
   }
@@ -1547,13 +2864,46 @@ class MemoryEngine {
     let run
     try {
       // prompt 必须是 block 数组(createUserMessage 校验 content.some)
+      const subModel = String(this.config.subagentModel || '').trim()
       run = await subagents.start(providerName, {
         label,
         prompt: [{ type: 'text', text }],
         signal: controller.signal,
         ...(parent ? { parent } : {}),
+        // 设置页「总结/问候默认模型」:非空时覆盖子代理的模型选择(空=跟随路由默认)
+        ...(subModel ? { agentOptions: { model: subModel } } : {}),
       })
-      const result = await run.result
+      // UNKNOWN_MODEL 自保:子代理路由为两源拼接(provider 继承父会话 + 模型落宿主全局默认),
+      // 父 provider 目录可能不含该模型(如 opencode-go-free × deepseek-v4-flash);
+      // 此时回退用父会话抽屉当前模型(settings.yaml agent-default-model)重试一次。
+      let result
+      try {
+        result = await run.result
+      } catch (eRoute) {
+        const em0 = eRoute && eRoute.message ? String(eRoute.message) : ''
+        if (!/UNKNOWN_MODEL|has no configured model/.test(em0)) throw eRoute
+        diag('subagent ' + label + ' UNKNOWN_MODEL fallback -> agent-default-model')
+        let fbModel = ''
+        let fbProvider = ''
+        try {
+          const rawCfg = await readFile(path.join(dshHome(), 'settings.yaml'), 'utf8')
+          // agent-default-model 是 provider+model 一对;仅取 model 而不换 provider 会继续 UNKNOWN_MODEL
+          const mFb = String(rawCfg).match(/agent-default-model:[\s\S]{0,200}?\n\s*provider:\s*([^\s#]+)/)
+          const mFm = String(rawCfg).match(/agent-default-model:[\s\S]{0,200}?\n\s*model:\s*([^\s#]+)/)
+          if (mFm) fbModel = mFm[1].trim()
+          if (mFb) fbProvider = mFb[1].trim()
+        } catch (eFs) {}
+        if (!fbModel) throw eRoute
+        diag('subagent ' + label + ' fallback model: ' + fbModel + ' @ ' + (fbProvider || providerName))
+        const run2 = await subagents.start(fbProvider || providerName, {
+          label,
+          prompt: [{ type: 'text', text }],
+          signal: controller.signal,
+          ...(parent ? { parent } : {}),
+          agentOptions: { model: fbModel },
+        })
+        result = await run2.result
+      }
       const blocks = result && result.output ? result.output : []
       return blocks.filter((b) => b && b.type === 'text').map((b) => b.text).join('').trim()
     } catch (e) {
@@ -1584,11 +2934,12 @@ class MemoryEngine {
   /** 每轮对话结束自动沉淀:取本轮 user+assistant 消息 → subagent 判断/提炼 → 写今日日志+升格。 */
   async consolidateTurn(turn, agent) {
     const why = (reason) => diag('consolidate skip: ' + reason + ' (turn=' + JSON.stringify(turn) + ' agentId=' + ((agent && (agent.id || (agent.session && agent.session.id))) || '?') + ')')
+    const runtime = this.runtimeFor(agent || this.currentRuntime().agent)
     // 声明提到函数级:异步 IIFE 与 try 块各自作用域,块内 let 在外面不可见(曾导致 userText is not defined)
     let userText = ''
     let assistantText = ''
     try {
-    if (this._consolidating) { why('_consolidating busy'); return }
+    if (runtime.consolidating) { why('runtime consolidating busy'); return }
     if (!this.configLoaded) { try { await this.loadConfig() } catch (e) {} }
     if (this.config.autoConsolidate === false) { why('config.autoConsolidate=false'); return }
     if (!agent || !agent.session) { why('no agent/session'); return }
@@ -1603,28 +2954,92 @@ class MemoryEngine {
     const cooldownMs = baseCooldown * 60000 * ((hourNow >= 22 || hourNow < 8) ? 2 : 1)
     const dailyMax = Math.max(Number(this.config.autoConsolidateDailyMax) || 8, 1)
     if (this._autoCallCount >= dailyMax) { why('daily subagent cap=' + dailyMax); return }
-    if (this._lastConsolidateStartedAt && Date.now() - this._lastConsolidateStartedAt < cooldownMs) { why('cooldown'); return }
-    // 按 turn 去重:同一 agent 的同一轮只处理一次
-    const agentId = agent.id || (agent.session && agent.session.id) || '?'
-    if (!this._lastTurnByAgent) this._lastTurnByAgent = new Map()
-    const lastTurn = this._lastTurnByAgent.get(agentId)
-    if (lastTurn === turn) { why('dup turn'); return }
-    this._lastTurnByAgent.set(agentId, turn)
+    if (runtime.lastConsolidateAt && Date.now() - runtime.lastConsolidateAt < cooldownMs) { why('cooldown'); return }
+    // 按 turn 去重:同一 agent 的同一轮只处理一次(runtime 隔离)
+    if (runtime.lastTurn === turn) { why('dup turn'); return }
+    runtime.lastTurn = turn
     // 取本轮最后一条 user + 最后一条 assistant(模型可见消息序列)
     const messages = extractSessionMessages(agent)
     if (messages.length < 2) { why('messages<2 got=' + messages.length + ' seqs=' + ((agent.session.surface && agent.session.surface.nodes && (Array.isArray(agent.session.surface.nodes) ? agent.session.surface.nodes.length : 'set')) || 'none') + ' events=' + ((agent.session.events && agent.session.events.length) || 'none')); return }
-    for (const m of messages) {
-      if (m.role === 'user') userText = m.text
-      else if (m.role === 'assistant' && m.text) assistantText = m.text
-    }
+    // 2026-08-30 intent 提纯(三层):①只认真人消息事件 'user/message'(tool/result 在协议里
+    // 也是 user 角色,正文常是 JSON/行号文本)②跳过 harness 合成的上下文注入消息
+    // ("Current runtime context." 开头 / 含 <memory_system>)③剥离注入快照块,取其后真人问题。
+    // 逻辑已抽到 lib/intent-clean.js(纯函数,可回归锁定),此处只做等价调用。
+    const picked = pickConsolidationTextPre(messages)
+    userText = picked.userText
+    assistantText = picked.assistantText
     if (!userText.trim() || !assistantText.trim()) { why('empty text user=' + userText.length + ' asst=' + assistantText.length); return }
     const combined = userText + '\n' + assistantText
     if (combined.length < minChars) { why('too short combined=' + combined.length + ' min=' + minChars); return }
-    this._lastConsolidateStartedAt = Date.now()
+    runtime.lastConsolidateAt = Date.now()
     this._autoCallCount++
     diag('consolidate subagent start count=' + this._autoCallCount + '/' + dailyMax + ' inputChars=' + Math.min(combined.length, 6000))
+    // M8 啮合 P0③:本轮记入记忆中枢 episodic(累积段)→ 达 minSegments 巩固成 episode →
+    // crossFeed 举一反三(success episode→procedure 观察;未决→fact 候选)。memoryHubEnabled
+    // 门;全 fail-closed 静默,不阻断自动沉淀主流程。注意:本方法内作用域是引擎实例(this)。
+    try {
+      const hub = this._memoryHub
+      if (this.config.memoryHubEnabled === true && hub && hub.stores && hub.stores.episodic) {
+        const ar = hub.stores.episodic.append({
+          sessionRef: String(runtime.sessionId || 'unknown').slice(0, 48),
+          userText: userText.slice(0, 200),
+          assistantText: assistantText.slice(0, 200),
+          kind: 'user', eventSeq: Number(turn) || 0,
+        })
+        if (ar && ar.ok) {
+          // 注意:episodic store 的 consolidate() 在段数不足 minSegments 时丢弃缓冲
+          // (current=null),因此不能每次 append 都调——本地计数攒够再巩固。
+          const minSegs = Math.max(1, Number(this.config.episodicMinSegments) || 2)
+          this._hubEpBuffer = (this._hubEpBuffer || 0) + 1
+          if (this._hubEpBuffer >= minSegs) {
+            this._hubEpBuffer = 0
+            const cr = hub.stores.episodic.consolidate()
+            if (cr && cr.ok && cr.episode) {
+              const cf = hub.crossFeed(cr.episode.sessionRef)
+              diag('hub episode consolidated: ' + String(cr.episode.episodeId).slice(0, 20) + ' crossFeed=' + ((cf && cf.fed && cf.fed.length) || 0))
+            } else {
+              diag('hub episodic consolidate: ' + String(cr && cr.reason || 'unknown'))
+            }
+          }
+          // M9: success evidence——本轮 substantive 且记忆被 read/cite → procedure
+          // addEvidence(success) 驱动晋升。修复 createSuccessEvidencePre 全仓零调用。
+          try {
+            const procs = hub.stores.procedures
+            const ch = this._contextHost
+            if (procs && ch && typeof ch.recentEvidenceForSuccess === 'function') {
+              const cited = ch.recentEvidenceForSuccess(5 * 60 * 1000)
+              if (cited.length) {
+                const sr = String(runtime.sessionId || '').slice(0, 48)
+                const allProcs = procs.query()
+                const successEvs = []
+                for (const e of cited) {
+                  for (const p of allProcs) {
+                    if (!(p.sourceMemoryIds || []).includes(e.memoryId)) continue
+                    procs.addEvidence(p.procedureId, { kind: 'success', sessionRef: sr })
+                  }
+                  const r = createSuccessEvidencePre({
+                    sessionId: runtime.sessionId || '', eventSeq: e.eventSeq || 0,
+                    nativeSeq: e.nativeSeq, contextVersion: e.contextVersion || 0,
+                    workspaceKey: e.workspaceKey || '', ts: Date.now(),
+                    memoryId: e.memoryId, anchorId: e.anchorId, scope: e.scope,
+                    sourceRef: e.sourceRef, sourceEpoch: e.sourceEpoch,
+                    sourceVersion: e.sourceVersion, fileDigest: e.fileDigest,
+                    recordDigest: e.recordDigest,
+                  })
+                  if (r.ok) successEvs.push(r.evidence)
+                }
+                if (successEvs.length) {
+                  ch.appendEvidence(successEvs)
+                  diag('hub success evidence: +' + successEvs.length)
+                }
+              }
+            }
+          } catch (_) {}
+        }
+      }
+    } catch (e) { diag('hub episodic hook error: ' + String(e && e.message || e).slice(0, 80)) }
     } catch (e) { diag('consolidate pre-flight error: ' + (e && (e.stack || e.message) || e)); return }
-    this._consolidating = (async () => {
+    runtime.consolidating = (async () => {
       try {
         await this.refresh(agent)
         const p = await this.resolvePaths(agent)
@@ -1664,8 +3079,7 @@ class MemoryEngine {
         if (!text) {
           diag('consolidate: subagent returned empty text (queued for retry)')
           // subagent 失败(返回空):入重试队列,由后台轮询兜底重试
-          if (!this._pendingConsolidations) this._pendingConsolidations = []
-          if (this._pendingConsolidations.length < 5) this._pendingConsolidations.push({ turn, agent })
+          if (runtime.pendingConsolidations.length < 5) runtime.pendingConsolidations.push({ turn, agent })
           return
         }
         if (text.includes('(无)')) return
@@ -1732,10 +3146,10 @@ class MemoryEngine {
       } catch (e) {
         console.error('[dsh-auto-memory] consolidateTurn failed', e && e.message ? e.message : e)
       } finally {
-        this._consolidating = undefined
+        runtime.consolidating = undefined
       }
     })()
-    await this._consolidating
+    await runtime.consolidating
   }
 
   /** AI 主动固化(做梦式):读最近日志 → 发散提炼 → 项目笔记/用户级 MEMORY.md 带日期标题。 */
@@ -1850,6 +3264,9 @@ class MemoryEngine {
     const p = await this.resolvePaths(agent)
     const cutoff = new Date()
     cutoff.setDate(cutoff.getDate() - days)
+    // 归档截止取「日期零点」而非当前时刻:否则凌晨 0:00-日界窗口内,当天(按日界归属)日志
+    // 会因 log.date(零点) < cutoff(含时分秒)被误判为旧日志而归档掉(2026-08-24 凌晨窗口实测)。
+    cutoff.setHours(0, 0, 0, 0)
     const logs = await this.listDailyLogs(p.projectDir, 365)
     const oldLogs = logs.filter((log) => {
       const m = DATE_RE.exec(log.date)
@@ -1895,7 +3312,7 @@ class MemoryEngine {
       try {
         const text = await this.readTextSafe(path.join(p.projectDir, log.name))
         if (text) { await this.writeFull(path.join(archiveDir, log.name), text); archived.push(log.name) }
-      } catch (e) {}
+      } catch (e) { console.error('[dsh-auto-memory] maintain archive failed for ' + log.name + ':', e && e.message ? e.message : e) }
     }
     // 3) 蒸馏结果写项目笔记;无 AI 时原样归档段保底
     let noteMsg = ''
@@ -1956,6 +3373,7 @@ class MemoryEngine {
       // 时间检测:暂离状态 / 待展示的自动总结 / 相关配置
       away: !!this.state.away,
       awayMinutes: Math.max(Number(this.config.awayMinutes) || 60, 1),
+      autoPopupEnabled: this.config.autoPopupEnabled !== false,
       autoSummaryTimes: Array.isArray(this.config.autoSummaryTimes) ? this.config.autoSummaryTimes : [],
       pendingSummary: this.state.pendingSummary || null,
       autoStats: this.autoStats,
@@ -2442,7 +3860,7 @@ function sanitizeForWrite(text, opts) {
   if (b64line) return { ok: false, reason: 'base64', clean: '' }
   if (raw.length > maxEntry) {
     // 超长: 截断并标记(防止整篇文档吸入; 正常条目极少超过)
-    return { ok: true, clean: raw.slice(0, maxEntry), truncated: true }
+    return { ok: true, clean: sanitizeReservedSyntax(raw.slice(0, maxEntry)), truncated: true }
   }
   // 连续行重复(同一段一模一样的行连续 ≥3 次 → 疑似退化 writer 循环; 空行打断连续, 避免把不同段落里相同的短行误判为循环)
   var seq = 0, prev = '', repeated = false
@@ -2452,7 +3870,14 @@ function sanitizeForWrite(text, opts) {
     if (t === prev) { seq++; if (seq >= 3) { repeated = true; break } } else { prev = t; seq = 1 }
   }
   if (repeated) return { ok: false, reason: 'duplicate-lines' }
-  return { ok: true, clean: raw }
+  return { ok: true, clean: sanitizeReservedSyntax(raw) }
+}
+
+/** M3b-4 保留语法卫生:字面 '<!-- memory:' 与记忆 anchor 保留语法冲突(写入后 parseAnchors 判 orphan-content,
+ *  开启 memoryAnchorEnabled 时文件锁死不可写)。写入前统一改写为豁免形式 '<!--memory:'(冒号后无空格),
+ *  不构成保留子串,内容语义不变(文档/示例可读)。 */
+function sanitizeReservedSyntax(text) {
+  return String(text || '').replace(/<!-- memory:/g, '<!--memory:')
 }
 /** 写闸门拦截原因 → 中文说明(供三个写入工具返回信息)。 */
 var WRITE_GATE_REASON = { empty: '内容为空', mojibake: '疑似乱码/错误编码往返', stutter: '疑似复读退化', 'duplicate-lines': '疑似重复内容块', 'raw-json': '疑似外部画像 raw JSON envelope', base64: '疑似 base64 编码残骸行' }
@@ -2555,7 +3980,7 @@ function extractSessionMessages(agent) {
       const ev = events[i]
       const msg = messageOfEvent(ev)
       if (!msg || !msg.role || !Array.isArray(msg.content)) continue
-      out.push({ role: msg.role, text: textOfContent(msg.content), sourceKind: msg.source && msg.source.kind })
+      out.push({ role: msg.role, text: textOfContent(msg.content), sourceKind: msg.source && msg.source.kind, eventType: ev.type })
     }
     return out
   } catch (e) { return [] }
@@ -2621,15 +4046,369 @@ export function apply(ctx, config) {
     }
   } catch (e) {}
   const engine = new MemoryEngine()
+  // M4-3:Shadow Retrieval Host 接线(三开关全开时才构造状态/IO;默认关闭零留存)
+  engine._shadowHost = createShadowHost({ engine })
+  // M5-3:Context Bridge Host 接线(assoc+contextBridge 双门;默认关闭零构造/零 IO)
+  engine._contextHost = createContextHost({ engine })
+  // M6-3:Activation Inbox Host 接线(assoc+activationInbox 双门;默认关闭)
+  engine._activationHost = createActivationHost({ engine })
+  // M7-8:Host Index Sync Orchestrator(四门全开才启用;默认关闭零 IO;修复 M7-8 Phase E blocker)
+  engine._indexSyncHost = createIndexSyncHostPre({ engine })
+  // M8:记忆中枢(Memory Hub)编排器 —— 三层记忆(episodic/semantic/procedural)。
+  // 惰性:默认关时三层 store 仍构造(纯内存零 IO),但消费链不启动;
+  // 开启后经 memoryHubEnabled 门消费 judgement-shadow + 提供 overview 端点。
+  // 2026-08-28 啮合 P0①:三店持久化 io(~/.dsh/memory/hub/,原子 tmp+rename)+启动 restore
+  // (此前 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 (_) {} },
+      }
+    }
+    engine._memoryHub = createMemoryHubPre({
+      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') }),
+        procedures: createProcedureStorePre({
+          // 2026-08-30 修复:gates 用 getter 活读 engine.config——挂载(apply 同步)时
+          // engine.config 尚未 loadConfig,静态读会冻结 DEFAULT(3/2),设置页改门槛永不生效
+          gates: {
+            // 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 maxContradictions() { return 0 },
+            get highRiskRequiresApproval() { return engine.config.procedureHighRiskApproval !== false },
+          },
+          activeLevel: engine.config.procedureActiveLevel || 'checklist',
+          io: hubIo('procedures.json'),
+        }),
+      },
+    })
+    try {
+      // restore 逐条校验,坏记录跳过(fail closed 幂等恢复);无文件/损坏 → 空启动
+      const eData = hubIo('episodes.json').load()
+      if (eData) engine._memoryHub.stores.episodic.restore(eData)
+      const fData = hubIo('facts.json').load()
+      if (fData) engine._memoryHub.stores.facts.restore(fData)
+      const pData = hubIo('procedures.json').load()
+      if (pData) engine._memoryHub.stores.procedures.restore(pData)
+    } catch (_) {}
+  }
+  // ---------- M10 存储管理编排器(2026-08-30 P3) ----------
+  // 原语(docStore.replace / rebuildSidecar / activationHost.purgeMemory / factStore.revokeBySource)
+  // 此前零调用方,此处组装成「扫描 → 修复 → 删除三联动」三个动作,经 loopback 端点与
+  // 设置页「存储管理」消费。docStore 与 hub 均为懒加载 → 用 getter 活读,apply 同步阶段安全。
+  engine._storageManager = createStorageManagerPre({
+    get docStore() { return engine.docStore },
+    io: { sidecarDir: path.join(dshHome(), 'memory', 'index', 'files'), readFileSync },
+    pathsOf: () => (engine.state && engine.state.ws ? {
+      workspaceKey: canonicalize(engine.state.ws),
+      userMemoryPath: engine.state.userDir ? path.join(engine.state.userDir, 'MEMORY.md') : undefined,
+      workspaceMemoryPath: engine.state.notesPath,
+      todayLogPath: engine.state.logPath,
+    } : null),
+    activationHostOf: () => engine._activationHost || null,
+    factStoreOf: () => (engine._memoryHub && engine._memoryHub.stores ? engine._memoryHub.stores.facts : null),
+  })
+
+  // ---------- M8 啮合 P0②/P1④:judgement 文件队列喂数 + fact 治理式写回 ----------
+  // 喂数:60s 轮询 semantic/judgement-shadow.jsonl(Python 建议行)增量 → heading 富化 →
+  // hub.ingestJudgement。memoryHubEnabled 门;行无 subject/predicate(memoryId 级建议),
+  // 富化用 sidecar 语料记录的 heading/text;不可解析的行跳过。js-decide-shadow.jsonl 不喂
+  // (JS 判定行无候选载荷,JS 侧记忆供给走 episodic/crossFeed 直接入店)。
+  // 写回:P1④ 主闭环——hub.facts 中 confirmed/未过期/未撤销/置信≥0.6 的事实,每日限额
+  // 治理式写入 notesPath/userFile(autoConsolidate 同款 appendText 原子事务)→ 进 M7 语料。
+  {
+    const hubFeedState = { shadow: null } // 文件指纹 {size,mtimeMs,count}
+    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 = () => {
+      try { const d = JSON.parse(readFileSync(hubFlushFile(), 'utf8')); if (d && typeof d === 'object') { hubFlushState.date = String(d.date || ''); hubFlushState.count = Number(d.count) || 0; hubFlushState.flushed = d.flushed || {} } } catch (_) {}
+    }
+    const hubFlushSave = () => {
+      try { mkdirSync(path.dirname(hubFlushFile()), { recursive: true }); writeFileSync(hubFlushFile(), JSON.stringify({ date: hubFlushState.date, count: hubFlushState.count, flushed: hubFlushState.flushed }), 'utf8') } catch (_) {}
+    }
+    hubFlushLoad()
+    // 语料查询器(heading 富化用):与 context-host 同源 sidecar 目录,懒建缓存
+    let hubCorpusCache = { key: '', snap: null }
+    const hubCorpusLookup = async (memoryId) => {
+      try {
+        const rt = engine.currentRuntime()
+        const p = await engine.resolvePaths(rt && rt.agent)
+        const key = canonicalize(p.notesPath || p.ws || '')
+        if (!key) return null
+        if (hubCorpusCache.key !== key || !hubCorpusCache.snap) {
+          const cat = buildSourceCatalog({ workspaceKey: p.ws || '', userMemoryPath: p.userFile, workspaceMemoryPath: p.notesPath, todayLogPath: p.logPath })
+          if (!engine._hubCorpusRegistry) engine._hubCorpusRegistry = new CorpusRegistry({ sidecarDir: path.join(dshHome(), 'memory', 'index', 'files') })
+          const res = engine._hubCorpusRegistry.get(cat)
+          if (!(res && res.ok)) return null
+          hubCorpusCache = { key, snap: res.snapshot }
+        }
+        return (hubCorpusCache.snap.records || []).find((r) => r.memoryId === memoryId) || null
+      } catch (_) { return null }
+    }
+    const hubFeedTick = () => {
+      try {
+        if (engine.config.memoryHubEnabled !== true) return
+        const hub = engine._memoryHub
+        if (!hub || !hub.ingestJudgementRows) return
+        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 // 文件被截断则只取尾部
+        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 (_) {}
+        }
+        hubFeedState.shadow = { size: st.size, mtimeMs: st.mtimeMs, count: lines.length }
+        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)
+                }
+              }
+              const r = hub.ingestJudgement(row)
+              if (r && r.consumed) fed++
+            } catch (_) {}
+          }
+          if (fed) diag('hub feed: +' + fed + '/' + newRows.length + ' rows consumed')
+        })()
+      } catch (_) {}
+    }
+    const hubFlushTick = async () => {
+      try {
+        if (engine.config.memoryHubEnabled !== true) return
+        const hub = engine._memoryHub
+        if (!hub || !hub.stores.facts) return
+        const today = engine.memToday()
+        if (hubFlushState.date !== today) { hubFlushState.date = today; hubFlushState.count = 0 }
+        const DAILY_MAX = 8
+        if (hubFlushState.count >= DAILY_MAX) return
+        const facts = hub.stores.facts.query ? hub.stores.facts.query() : []
+        const now = Date.now()
+        let p = null
+        for (const fact of facts) {
+          if (hubFlushState.count >= DAILY_MAX) break
+          if (!fact || fact.revoked || hubFlushState.flushed[fact.factId]) continue
+          if (fact.ttl && now >= (fact.confirmedAt || 0) + fact.ttl) continue
+          if (typeof fact.confidence === 'number' && fact.confidence < 0.6) continue
+          const subj = String(fact.subject || '').trim()
+          if (!subj || subj.startsWith('mem_')) continue // 无富化的 memoryId 主语不入正文
+          try {
+            if (!p) p = await engine.resolvePaths(engine.currentRuntime().agent)
+            const target = fact.scope === 'User' ? p.userFile : p.notesPath
+            if (!target) continue
+            const cur = await engine.readTextSafe(target)
+            if (cur && cur.includes(subj)) { hubFlushState.flushed[fact.factId] = true; continue } // 已在正文,只记标记
+            const body = '\n## ' + subj + '（M8 固化）\n- ' + String(fact.predicate || '要点') + (fact.object ? '：' + String(fact.object) : '') + '\n- 来源：记忆中枢治理固化' + (typeof fact.confidence === 'number' ? '（confidence=' + fact.confidence.toFixed(2) + '）' : '')
+            const written = await engine.appendText(target, body)
+            try { if (engine.state) { if (fact.scope === 'User') engine.state.userText = written; else engine.state.notesText = written } } catch (_) {}
+            hubFlushState.flushed[fact.factId] = true
+            hubFlushState.count++
+            diag('hub flush: fact ' + String(fact.factId).slice(0, 16) + ' → ' + (fact.scope === 'User' ? 'user' : 'notes'))
+          } catch (_) {}
+        }
+        hubFlushSave()
+      } catch (_) {}
+    }
+    const hubFeedTimer = setInterval(hubFeedTick, 60 * 1000)
+    const hubFlushTimer = setInterval(() => { void hubFlushTick() }, 30 * 60 * 1000)
+    // unref:定时器不阻止进程退出(测试 settle 不经过 apply 的 disposer 链会挂住)
+    hubFeedTimer.unref(); hubFlushTimer.unref()
+    const hubBootTimer = setTimeout(() => { hubFeedTick(); void hubFlushTick() }, 90 * 1000)
+    hubBootTimer.unref()
+    if (!engine._hubFeedDisposers) engine._hubFeedDisposers = []
+    engine._hubFeedDisposers.push(() => { clearInterval(hubFeedTimer); clearInterval(hubFlushTimer) })
+  }
+  // C2 内置语义引擎宿主(2026-08-26 用户裁定:C2=默认主路径)。懒加载 e5-small q8;
+  // 只做检索排序,激活决策仍属两车道策略。下载器落位=发行包布局 lib/models。
+  {
+    const pluginDir = path.dirname(fileURLToPath(import.meta.url))
+    engine._jsSemantic = createJsSemanticEnginePre({ pluginDir })
+    engine._jsDownload = createSemanticDownloaderPre({ modelsRoot: path.join(pluginDir, 'models') })
+    // 资产探测(semantic-status / 档位解析 / 引导卡共用):发行包 models/ 优先,其次开发树
+    engine.semanticAssetProbe = async () => {
+      const fsMod = await import('node:fs')
+      const cands = [
+        path.join(pluginDir, 'models', 'multilingual-e5-small', 'onnx', 'model_quantized.onnx'),
+        path.join(pluginDir, '..', 'artifacts', 'm7-live-pre', 'js-semantic-trial', 'models', 'multilingual-e5-small', 'onnx', 'model_quantized.onnx'),
+      ]
+      const modelOnnx = cands.find((c) => fsMod.existsSync(c)) || cands[0]
+      const peerCands = [
+        path.join(pluginDir, 'node_modules', '@huggingface', 'transformers'),
+        path.join(pluginDir, '..', 'artifacts', 'm7-live-pre', 'js-semantic-trial', 'node_modules', '@huggingface', 'transformers'),
+      ]
+      const peerDir = peerCands.find((c) => fsMod.existsSync(c)) || peerCands[0]
+      const assetPresent = fsMod.existsSync(modelOnnx)
+      return {
+        assetPresent,
+        peerPresent: fsMod.existsSync(peerDir),
+        ready: Boolean(assetPresent && fsMod.existsSync(peerDir)),
+        assetBytes: assetPresent ? fsMod.statSync(modelOnnx).size : 0,
+        assetPath: modelOnnx,
+      }
+    }
+    // 档位解析:lexical→C1 强制保底;其余(auto/js/python)在资产就绪时启用 C2 臂
+    // (python 模式下 C2 只改善 envelope.refs/candidateHit,sink 检索仍归 sidecar)。
+    engine.resolveSemanticTier = async () => {
+      const mode = String(engine.config.semanticEngineMode || 'auto')
+      // 2026-08-27 修正:区分引擎模式(修复「怎么切都显示 C2」)。
+      // lexical→c1 强制;python→c3(高级档);auto/js→资产就绪 c2 否则 c1。
+      if (mode === 'lexical') return 'c1'
+      if (mode === 'python') return 'c3'
+      try { return (await engine.semanticAssetProbe()).ready ? 'c2' : 'c1' } catch (_) { return 'c1' }
+    }
+    // context-host refs 选择钩子:C2 就绪时返回 {scores:Map};任何失败回退词法序。
+    engine._jsSemanticRank = async (corpusSnap, queryText) => {
+      try {
+        if ((await engine.resolveSemanticTier()) !== 'c2') return null
+        return await engine._jsSemantic.rank(corpusSnap, queryText)
+      } catch (_) { return null }
+    }
+    // JS 端判定核(2026-08-27):读策略工件(懒加载+缓存),对 C2 检索结果做 fv2 决策。
+    // 完全独立于 Python——JS 端默认闭环(C2 检索 + JS 判定 + M6 投递)的核心。
+    engine._jsDecideCtx = null
+    engine._jsDecideErr = ''
+    engine.ensureJsDecide = () => {
+      try {
+        if (engine._jsDecideCtx) return engine._jsDecideCtx
+        // 策略工件多路径探测:JS 侧 lib/policies 优先(纯 JS 部署必达,npm 包 JS-only 也含);
+        // fallback python/policies(兼容旧部署)。纯 JS 用户系统无 Python,必须能从 JS 侧读到。
+        const pluginDir = path.dirname(fileURLToPath(import.meta.url))
+        const jsPolicyDir = path.join(pluginDir, 'policies')
+        const pyPolicyDir = path.join(pluginRootDir(), 'python', 'policies')
+        const jsIntent = path.join(jsPolicyDir, 'recall_intent_lr_v1.json')
+        const jsAct = path.join(jsPolicyDir, 'activation_policy_v2.json')
+        const intentPath = existsSync(jsIntent) ? jsIntent : path.join(pyPolicyDir, 'recall_intent_lr_v1.json')
+        const actPath = existsSync(jsAct) ? jsAct : path.join(pyPolicyDir, 'activation_policy_v2.json')
+        engine._jsDecideCtx = loadAndVerifyPolicy(intentPath, actPath)
+        return engine._jsDecideCtx
+      } catch (e) {
+        engine._jsDecideErr = String(e && e.message || e).slice(0, 160)
+        return null
+      }
+    }
+    // JS 发射门(2026-08-27):读 embedding-config.json 的 activationEmitMode(与 Python worker 同源)。
+    // shadow=只记录不注入;canary-explicit/active=注入。JS 判定 emit 前必须过此门。
+    // 5 秒缓存避免每次判定都读盘(设置页 semantic-emit 写后 5 秒内生效)。
+    engine._jsEmitCache = { at: 0, mode: '' }
+    engine.jsEmitMode = () => {
+      const now = Date.now()
+      if (now - engine._jsEmitCache.at < 5000) return engine._jsEmitCache.mode || 'shadow'
+      try {
+        const raw = JSON.parse(readFileSync(path.join(dshHome(), 'memory', 'semantic', 'embedding-config.json'), 'utf8'))
+        const em = String((raw && raw.activationEmitMode) || 'shadow')
+        const mode = ['shadow', 'canary-explicit', 'active'].includes(em) ? em : 'shadow'
+        engine._jsEmitCache = { at: now, mode }
+        return mode
+      } catch (_) { return 'shadow' }
+    }
+    // JS 判定入口:输入 C2 排名结果 + envelope 上下文,输出 fv2 决策。
+    // 返回 { ok, decision, lane, reasonCodes, features } 或 { ok:false }。
+    engine._jsDecide = async (queryText, rankRes, envelope) => {
+      try {
+        const ctx = engine.ensureJsDecide()
+        if (!ctx) return { ok: false, reason: 'policy-unavailable: ' + engine._jsDecideErr }
+        // 从 rankRes 构建特征:candidateHit=refs 与语义候选重叠
+        const refIds = new Set((envelope && envelope.memoryRefs || []).map((r) => r.memoryId))
+        const scores = rankRes && rankRes.scores
+        // 2026-08-28 孪生对齐(浏览器实调发现):Python fv2 的候选池=稠密 top-8(SHADOW_TOP_K),
+        // 按 D6 融合序重排,margin=融合第1/2名的稠密分差(worker_semantic_v1.py dense_search
+        // top_k=8 + hybrid_rank + candidates[0/1]['score'])。JS 旧实现=全量裸稠密分 top1-top2,
+        // 在致密语料(105条同项目记忆)中恒 <deltaExp → emit 永不触发,与 held-out 校准分布脱节。
+        let candIds = []
+        let denseTop = 0
+        let margin = 0
+        let nCand = 0
+        if (scores && scores.size) {
+          const lexMap = (rankRes._lex instanceof Map) ? rankRes._lex : new Map()
+          const denseSorted = [...scores.entries()].sort((a, b) => b[1] - a[1]).slice(0, 8)
+          const fusedOrder = fuseD6Pre(denseSorted.map(([id, d]) => ({ memoryId: id, dense: d, lex: lexMap.get(id) || 0 })))
+          const ordered = (fusedOrder.length ? fusedOrder : denseSorted.map(([id]) => ({ memoryId: id })))
+            .map((f) => ({ memoryId: f.memoryId, dense: scores.get(f.memoryId) || 0 }))
+          candIds = ordered.map((c) => c.memoryId)
+          denseTop = ordered.length ? ordered[0].dense : 0
+          margin = ordered.length > 1 ? Math.max(0, denseTop - ordered[1].dense) : (ordered.length ? denseTop : 0)
+          nCand = ordered.length
+        }
+        const candidateHit = [...refIds].some((id) => candIds.includes(id))
+        const topRec = candIds.length ? ((rankRes._records || []).find((r) => r.memoryId === candIds[0]) || null) : null
+        const containment = topRec ? lexicalContainment(queryText, topRec.text || '') : 0
+        const tl = String(queryText || '').toLowerCase()
+        const mark = (['？', '?', '什么', '如何', '怎么', '哪些', '哪个', '为什么', '多少', '吗', '呢', '是不是', '有没有', '之前', '上次', '当时'].some((k) => tl.includes(k))) ? 1 : 0
+        const features = {
+          text: String(queryText || '').slice(0, 2000),
+          denseTop, margin, containment, mark,
+          nCand, candidateHit,
+          hardGates: {},
+          requiresRelayFlag: false, piiClass: 'unknown',
+        }
+        // 2026-08-28 e5 校准增量:JS 档用配置覆盖 deltaExp(克隆 policy,冻结决策核不动)。
+        // bge-m3 校准的 0.03 对 e5 的压缩分布过严(live 实测 margin 0-0.0284 全被拦)。
+        let policy = ctx.policy
+        const deltaOverride = Number(engine.config.jsDecideDeltaExp)
+        if (Number.isFinite(deltaOverride) && deltaOverride >= 0 && policy && policy.thresholds) {
+          policy = Object.assign({}, policy, { thresholds: Object.assign({}, policy.thresholds, { deltaExp: deltaOverride }) })
+        }
+        const out = decideActivationV2(features, ctx.head, policy)
+        return { ok: true, decision: out.decision, lane: out.lane, reasonCodes: out.reasonCodes, features: out.features, _margin: margin, _denseTop: denseTop, _candN: nCand, _hit: candidateHit }
+      } catch (e) {
+        return { ok: false, reason: String(e && e.message || e).slice(0, 160) }
+      }
+    }
+  }
+  try { engine._activationHost.initCapability(ctx) } catch (_) {}
+  // M7-0/M7-1:engine 级共享 SidecarClient(对象构造零副作用;进程仅在显式启用路径上 lazy spawn,
+  // 默认关闭=零 Python process、零协议 IO、零 semantic 目录)
+  engine._pythonSidecar = createPythonSidecarClientPre({
+    command: () => String(engine.config.pythonBackendExecutable || '').trim() || 'python',
+    scriptPath: () => String(engine.config.pythonBackendWorkerPath || '').trim() || defaultWorkerScriptPathPre(),
+    dshHome: () => {
+      const env = process.env.DSH_HOME
+      if (env && env.trim()) return env.trim()
+      try { return path.join(homedir(), '.dsh') } catch (_) { return '' }
+    },
+  })
+  engine.__homedirFn = homedir
   const sessionQuery = ctx.get('sessionQuery')
   engine._sessionQuery = sessionQuery
   engine._subagents = ctx.get('subagents') || undefined
   // 时间检测用的服务(软获取,缺失时定时兜底自动降级)
   engine._sessionsSvc = ctx.get('sessions') || undefined
   engine._agentSvc = ctx.get('agent') || undefined
+  // 模型目录(设置页「总结/问候默认模型」抽屉数据源);软获取,缺失时抽屉回退手动输入
+  engine._llm = ctx.get('llm') || undefined
 
   // 生命周期刷新
-  const refreshAll = (agent) => { void engine.refresh(agent) }
+  const refreshAll = (agent) => {
+    void engine.refresh(agent).then(() => {
+      // M4-3:refresh 完成后同步捕获 paths 快照供 Shadow 调度(§7.2 禁止异步 tick 内裸调 resolvePaths)
+      try { if (engine._shadowHost && agent && engine.state.ws) engine._shadowHost.capturePaths(engine.runtimeFor(agent).key, engine.state) } catch (_) {}
+      // M5-3:同一 paths 快照共享给 Context Bridge(仅相对投影,不落盘路径)
+      try { if (engine._contextHost && agent && engine.state.ws) engine._contextHost.capturePaths(engine.runtimeFor(agent).key, engine.state) } catch (_) {}
+      // M6-3:同一 paths 快照共享给 Activation Inbox(corpus 查询用)
+      try { if (engine._activationHost && agent && engine.state.ws) engine._activationHost.capturePaths(engine.runtimeFor(agent).key, engine.state) } catch (_) {}
+    }).catch(() => {})
+  }
   refreshAll()
   // 自动检查更新:host 启动时查一次 npm registry(结果缓存 12 小时,设置页打开直接读缓存显示)
   void engine.checkUpdate(false)
@@ -2638,23 +4417,41 @@ export function apply(ctx, config) {
   const noticesTimer = setInterval(noticesRefresh, 3600 * 1000)
   void engine.fetchNotices(false).then((l) => { engine._noticesCache = l }).catch(() => {})
   ctx.on('agent/session-start', (payload) => {
-    refreshAll(payload && payload.agent)
-    // 缓存最近 agent 引用(subagent parent 需要完整 agent 对象)
-    try { if (payload && payload.agent) engine._lastAgent = payload.agent } catch (e) {}
+    // M0/M1: 建立该 agent/session 的 runtime(WeakMap/Map 登记),之后所有状态按 session 隔离。
+    // 审查修复轮2:生命周期入口同样走严格身份——无 session 身份的对象不得经 runtimeFor 伪造匿名 runtime,
+    // 也不得进入 _lastAgent(subagent parent 需要 session)。
+    try {
+      if (payload && payload.agent && engine.hasReliableSessionIdentity(payload.agent)) {
+        const rt = engine.runtimeFor(payload.agent)
+        engine._lastAgent = payload.agent
+        // M2.4: 对已存在的 session.events 按原生 seq 补放(live feed 之后从游标续接去重)
+        engine.seedRuntimeFromSession(payload.agent)
+        engine.ingestAgentLifecycle(payload.agent, 'agent/session-start', { payload: { source: boundedStr(payload && payload.source) } })
+      }
+    } catch (e) {}
+    // 审查修复轮3:refreshAll 同样受严格身份守卫 —— 匿名对象不得把 cwd 写进 default runtime state
+    const ssa = payload && payload.agent
+    if (!ssa || engine.hasReliableSessionIdentity(ssa)) refreshAll(ssa)
   })
   ctx.on('agent/turn-stopping', (payload) => {
-    refreshAll(payload && payload.agent)
-    // 记录最后活动时间(判断暂离回来用)
-    try { engine._lastActiveAt = Date.now() } catch (e) {}
+    // 审查修复轮3:refreshAll 只对可靠身份 agent 执行,匿名对象不得污染 default runtime state
+    const evtAgent = payload && payload.agent
+    if (!evtAgent || engine.hasReliableSessionIdentity(evtAgent)) refreshAll(evtAgent)
     // 每轮自动沉淀:取本轮消息 → subagent 判断/提炼 → 写今日日志([自动沉淀])+升格长期记忆
     try {
-      const agent = (payload && payload.agent) || engine._lastAgent
-      const hasAgent = !!(agent && agent.session)
-      diag('turn-stopping fired: turn=' + JSON.stringify(payload && payload.turn) + ' hasAgent=' + hasAgent + ' payloadKeys=' + (payload ? Object.keys(payload).join(',') : 'null') + ' _lastAgent=' + !!(engine._lastAgent && engine._lastAgent.session))
+      const agent = evtAgent
+      // 审查修复轮3:有效性判断必须是严格 session 身份 —— !!agent.session 会放行无身份对象
+      const hasAgent = !!(agent && engine.hasReliableSessionIdentity(agent))
+      if (hasAgent) {
+        // 最后活动时间写入该 agent 自己的 runtime(不再落到 currentRuntime()/default)
+        try { engine.runtimeFor(agent).lastActiveAt = Date.now() } catch (e) {}
+        try { engine.ingestAgentLifecycle(agent, 'agent/turn-stopping', { turn: payload && payload.turn, payload: { turn: payload && payload.turn } }) } catch (e) {}
+      }
+      diag('turn-stopping fired: turn=' + JSON.stringify(payload && payload.turn) + ' hasAgent=' + hasAgent + ' payloadKeys=' + (payload ? Object.keys(payload).join(',') : 'null'))
       if (hasAgent) {
         // 延迟到 turn-stopping 收尾完成后再启动 subagent,避免与 DSH 会话收尾竞争导致进程级崩溃
         setTimeout(() => {
-          void engine.consolidateTurn(payload.turn, agent).catch((e) => console.error('[dsh-auto-memory] consolidateTurn unhandled', e && (e.stack || e.message) || e))
+          void engine.withAgent(agent, () => engine.consolidateTurn(payload.turn, agent)).catch((e) => console.error('[dsh-auto-memory] consolidateTurn unhandled', e && (e.stack || e.message) || e))
         }, 600)
       }
     } catch (e) { diag('turn-stopping handler error: ' + (e && e.message)) }
@@ -2664,20 +4461,45 @@ export function apply(ctx, config) {
   // 首轮(loadedAt=0)必定 await 完 → 模型从第一个 token 起就看到记忆;之后每 15s 跟进轮间新写入。
   ctx.on('agent/pre-step', async (payload, next) => {
     try {
-      const agent = (payload && payload.agent) || engine._lastAgent
-      // 兜底恢复 _lastAgent(仅启动后首次为空时设置一次,不每步覆盖):重启后恢复的会话不触发 session-start,
-      // 导致 turn-stopping 自动沉淀拿不到 agent 而永久失效;首次 pre-step 即恢复,之后由 session-start 正常维护
-      try { if (!engine._lastAgent && agent && agent.session && agent.session.header && agent.session.header.parentSession === undefined) { engine._lastAgent = agent; diag('pre-step recovered _lastAgent id=' + agent.id) } } catch (e) {}
-      // 只刷新顶层会话:子代理(自动沉淀/固化的 subagent)session 无 cwd,刷新会把 state 切到错误工作区
-      let skip = false
-      try { if (agent && agent.session && agent.session.header && agent.session.header.parentSession) skip = true } catch (e) {}
-      if (!skip && agent && (!engine.state.loadedAt || Date.now() - engine.state.loadedAt > 15000)) {
-        await engine.refresh(agent)
+      const agent = payload && payload.agent   // M1: 精确取当前 agent 的 runtime,不猜
+      // 审查修复轮2:无 session 身份的 agent 不登记 runtime、不进 stateFor/refresh,直接放行
+      if (agent && engine.hasReliableSessionIdentity(agent)) {
+        // 首步即登记 runtime(重启恢复的会话也可能不触发 session-start,这里补登记)
+        const rt = engine.runtimeFor(agent)
+        // M7.5:pre-step 边界先冲刷 CoT 缓冲——保证本轮 context_push 的 window 携带最新思维链
+        try { engine.flushReasoningBuffer(rt) } catch (_) {}
+        engine.ingestAgentLifecycle(agent, 'agent/pre-step', { turn: payload && payload.turn, step: payload && payload.step, payload: { turn: payload && payload.turn, step: payload && payload.step } })
+        // M6-3:pre-step 时序(§8)——校验 cursor/index/TTL 后 claim packet,等待渲染面消费
+        try { if (engine._activationHost) engine._activationHost.onPreStep(agent) } catch (_) {}
+        // 只刷新顶层会话:子代理(自动沉淀/固化的 subagent)session 无 cwd,刷新会把 state 切到错误工作区
+        let skip = false
+        try { if (agent.session && agent.session.header && agent.session.header.parentSession) skip = true } catch (e) {}
+        const st = engine.stateFor(agent)
+        if (!skip && (!st.loadedAt || Date.now() - st.loadedAt > 15000)) {
+          await engine.refresh(agent)
+        }
       }
     } catch (e) {}
     return next()
   })
 
+  // M0/M1: agent/session 销毁时清理对应 runtime(abort 挂起任务 + 从 store 移除;M2 同步清空 ring/pending)
+  ctx.on('agent/disposed', (payload) => {
+    try { if (payload && payload.agent) engine.disposeAgent(payload.agent) } catch (e) {}
+  })
+  ctx.on('session/disposed', (session) => {
+    try { engine.runtimes.disposeSession(session) } catch (e) {}
+  })
+
+  // M2.1: 结构化事件入口 —— session/event(post-commit append feed)+ frozen tools/result(执行级最终观察点)。
+  // 只观察、有界最小投影;无可靠 owner 的事件被丢弃留痕,绝不落入 default runtime。
+  ctx.on('session/event', (session, event) => {
+    try { engine.observeSessionEvent(session, event) } catch (e) {}
+  })
+  ctx.on('tools/result', (exec, result) => {
+    try { engine.observeToolResult(exec, result) } catch (e) {}
+  })
+
   // ---------- 系统提示词注入 ----------
   // 动态记忆 → ctx.systemPrompt.context():渲染为 user-role 快照追加在历史尾部,内容不变不重复注入(dsh-agent-loop project() 去重)。
   // system prompt 不再包含动态内容 → 字节级稳定 → DeepSeek 前缀缓存全程命中(自动沉淀/跨天/切模型都不再击穿前缀)。
@@ -2688,10 +4510,63 @@ export function apply(ctx, config) {
       try {
         const agent = context && context.agent
         if (!agent) return ''
-        if (!engine.state.loadedAt || Date.now() - engine.state.loadedAt > 15000) {
-          void engine.refresh(agent)
-        }
-        return engine.renderMemoryDynamic(context) + engine.renderReflectionRequest()
+        // M0/M1: 绑定到该 agent 的 runtime 再读取(state 是 per-session getter,避免落到 default runtime 读到空)
+        return engine.withAgent(agent, () => {
+          const st = engine.stateFor(agent)
+          if (!st.loadedAt || Date.now() - st.loadedAt > 15000) {
+            void engine.refresh(agent)
+          }
+          // 2026-08-27 频率控制(在调用方做,不破坏 renderMemoryDynamic 契约):
+          // 指纹只基于"日志段"(recentLogs)——日志是每轮微变源。日志变化且距上次注入不足
+          // snapshotMinGapRounds 轮 → 暂缓;反思/用户/笔记/欢迎等结构性变化始终立即注入。
+          // 内容未变则正常返回(由 project 去重)。状态 per-agent(挂 runtime.state)防 A/B 串线。
+          const snap = engine.renderMemoryDynamic(context)
+          const gap = Math.max(0, Number(engine.config.snapshotMinGapRounds) || 5)
+          if (gap > 0 && snap) {
+            const st = engine.stateFor(agent)
+            // 2026-08-27 压缩检测:上下文压缩/截断常伴随 contextVersion 重置(归零/倒退)。
+            // 开启 snapshotReinjectOnCompact 时,压缩后绕过间隔立即重注入(快照被清掉后必须重建)。
+            try {
+              const rt = engine.runtimeFor(agent)
+              const cv = (rt && rt.contextVersion) || 0
+              if (engine.config.snapshotReinjectOnCompact !== false && st._snapCv !== undefined && cv < st._snapCv) {
+                st._snapLogFp = '' // 强制重注入:清掉指纹,下个分支当"日志变化"处理
+                st._snapPendingSnap = null
+                st._snapPendingLogFp = null
+              }
+              st._snapCv = cv
+            } catch (_) {}
+            // 日志段指纹:从快照中截出"最近 N 天工作日志"段(含标题行到下一个 [ 段)
+            const logMatch = snap.match(/\[最近 \d+ 天工作日志[^\]]*\][\s\S]*?(?=\n\[|\n<memory_system>|\n$)/)
+            const logFp = createHash('sha256').update(logMatch ? logMatch[0] : '').digest('hex').slice(0, 16)
+            if (logFp !== (st._snapLogFp || '')) {
+              // 日志变化:距上次注入不足间隔 → 暂缓
+              st._snapRound = (st._snapRound || 0) + 1
+              if (st._snapFp === undefined) {
+                st._snapFp = snap
+                st._snapLogFp = logFp
+                st._snapLastRound = st._snapRound
+              } else if (st._snapRound - (st._snapLastRound || 0) < gap) {
+                st._snapPendingSnap = snap
+                st._snapPendingLogFp = logFp
+                return engine.renderReflectionRequest()
+              } else {
+                st._snapFp = snap
+                st._snapLogFp = logFp
+                st._snapLastRound = st._snapRound
+              }
+            } else if (st._snapPendingSnap && logFp === st._snapPendingLogFp) {
+              // 日志已稳定到间隔:放行暂缓版本
+              st._snapFp = st._snapPendingSnap
+              st._snapLogFp = logFp
+              st._snapLastRound = st._snapRound
+              st._snapPendingSnap = null
+              st._snapPendingLogFp = null
+              return snap + engine.renderReflectionRequest()
+            }
+          }
+          return snap + engine.renderReflectionRequest()
+        })
       } catch (e) { return '' }
     },
   })
@@ -2703,6 +4578,20 @@ export function apply(ctx, config) {
       try { return engine.renderMemoryStatic() } catch (e) { return '' }
     },
   })
+  // M6-3:专用动态 Reference Tail context surface('dynamic-context' capability)。
+  // 仅渲染已 claimed 的 packet;返回非空=实际进入下一请求 messages → 同步 markDelivered + seen。
+  // systemPrompt.section 永不承载该动态内容。
+  const disposeTailSurface = ctx.systemPrompt.context({
+    name: 'dsh:m6-reference-tail-pre',
+    order: SECTION_ORDER + 1,
+    text: (context) => {
+      try {
+        const agent = context && context.agent
+        if (!agent || !engine._activationHost) return ''
+        return engine.withAgent(agent, () => engine._activationHost.renderTailFor(agent)) || ''
+      } catch (e) { return '' }
+    },
+  })
 
   // ---------- 工具 ----------
   const tools = [
@@ -2896,6 +4785,340 @@ export function apply(ctx, config) {
 
   // ---------- 路由 ----------
   const routes = [
+    {
+      kind: 'exact',
+      path: API['semantic-status'],
+      handler: async (req, res) => {
+        // M7.5 C2 资产检测(只读;loopback):供首启向导/设置页判断语义引擎就绪状态
+        if (!isLoopbackRequest(req)) return writeJson(res, 403, { error: 'forbidden: loopback-only' })
+        try {
+          const probe = await engine.semanticAssetProbe()
+          const pyCands = [
+            path.join(pluginRootDir(), 'python', 'bench', 'models-xenova-bge-m3-int8', 'onnx', 'model_int8.onnx'),
+          ]
+          const fsMod = await import('node:fs')
+          const pyOnnx = pyCands.find((c) => fsMod.existsSync(c)) || pyCands[0]
+          // 发射开关读数(memory/semantic/embedding-config.json 的
+          // activationEmitMode;worker 同源读取,缺省 shadow=fail closed)
+          let activationEmitMode = 'shadow'
+          try {
+            const emRaw = JSON.parse(fsMod.readFileSync(path.join(dshHome(), 'memory', 'semantic', 'embedding-config.json'), 'utf8'))
+            const em = String((emRaw && emRaw.activationEmitMode) || 'shadow')
+            if (['shadow', 'canary-explicit', 'active'].includes(em)) activationEmitMode = em
+          } catch (_) {}
+          const resolvedTier = await engine.resolveSemanticTier()
+          return writeJson(res, 200, {
+            engineDefault: 'js',
+            activationEmitMode,
+            resolvedTier,
+            jsSemantic: engine._jsSemantic ? engine._jsSemantic.status() : null,
+            download: engine._jsDownload ? engine._jsDownload.state() : null,
+            manifestBytes: E5_SMALL_Q8_MANIFEST_V1.totalBytes,
+            assetPresent: probe.assetPresent,
+            peerPresent: probe.peerPresent,
+            ready: probe.ready,
+            assetBytes: probe.assetBytes,
+            assetPath: probe.assetPath,
+            pythonInt8Present: fsMod.existsSync(pyOnnx),
+            pythonInt8Bytes: fsMod.existsSync(pyOnnx) ? fsMod.statSync(pyOnnx).size : 0,
+            tuning: {
+              tauHi: null, deltaExp: null, deltaPro: null, // 由策略 JSON 权威;设置页只读展示
+            },
+            note: 'C3 python int8 tier optional; fp32 suspended per 2026-08-26 ruling',
+          })
+        } catch (e) { return writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
+      },
+    },
+    {
+      kind: 'exact',
+      path: API['semantic-download'],
+      handler: async (req, res) => {
+        // C2 资产下载器(POST start/cancel;loopback-only)。GET 不支持——进度走 semantic-status。
+        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)
+        const action = String((body && body.action) || '')
+        if (action === 'start') {
+          const r = engine._jsDownload.start(body && body.mirror)
+          return writeJson(res, r.ok ? 200 : 400, Object.assign({ action: 'start' }, r))
+        }
+        if (action === 'cancel') {
+          const r = engine._jsDownload.cancel()
+          return writeJson(res, r.ok ? 200 : 409, Object.assign({ action: 'cancel' }, r))
+        }
+        return writeJson(res, 400, { error: 'invalid action' })
+      },
+    },
+    {
+      kind: 'exact',
+      path: API['semantic-emit'],
+      handler: async (req, res) => {
+        // 唤起注入模式(POST {mode:shadow|canary-explicit|active};loopback-only)。
+        // 写入 embedding-config.json 的 activationEmitMode,JS/Python 双轨同源读取。
+        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(() => ({}))
+        const mode = String((body && body.mode) || '')
+        if (!['shadow', 'canary-explicit', 'active'].includes(mode)) return writeJson(res, 400, { error: 'invalid mode' })
+        try {
+          const fsMod = await import('node:fs')
+          const pathMod = await import('node:path')
+          const cfgPath = pathMod.join(dshHome(), 'memory', 'semantic', 'embedding-config.json')
+          let cfg = {}
+          try { cfg = JSON.parse(fsMod.readFileSync(cfgPath, 'utf8')) } catch (_) {}
+          if (!cfg || typeof cfg !== 'object') cfg = {}
+          cfg.activationEmitMode = mode
+          fsMod.mkdirSync(pathMod.dirname(cfgPath), { recursive: true })
+          fsMod.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2), 'utf8')
+          return writeJson(res, 200, { ok: true, mode })
+        } catch (e) { return writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
+      },
+    },
+    {
+      kind: 'exact',
+      path: API['shadow-recent'],
+      handler: async (req, res) => {
+        // G-02 前置(只读;loopback):返回最近 shadow 决策行的脱敏投影,供「语料精修」面板渲染 A/P/S/H/E
+        if (!isLoopbackRequest(req)) return writeJson(res, 403, { error: 'forbidden: loopback-only' })
+        try {
+          const fsMod = await import('node:fs')
+          const pathMod = await import('node:path')
+          const file = pathMod.join(dshHome(), 'memory', 'semantic', 'activation-shadow-v2.jsonl')
+          if (!fsMod.existsSync(file)) return writeJson(res, 200, { rows: [] })
+          const all = fsMod.readFileSync(file, 'utf8').split('\n').filter(Boolean)
+          const tail = all.slice(-24).map((l) => {
+            try {
+              const r = JSON.parse(l)
+              const f = r.features || {}
+              return {
+                observationId: r.observationId, decision: r.decision,
+                reasonCodes: r.reasonCodes || [], lane: (f && f.lane) || r.lane || null,
+                intentProb: (f && f.intentProb) != null ? f.intentProb : null,
+                margin: (f && f.margin) != null ? f.margin : null,
+                candidateHit: r.candidateHit != null ? r.candidateHit : null,
+                maxLexRaw: r.maxLexRaw != null ? r.maxLexRaw : null,
+                memoryRefCount: Array.isArray(r.candidateProvenance) ? r.candidateProvenance.length : null,
+                // G-02 v1 增补:候选锚点前 3(8 字符前缀,脱敏——完整 id 不出端点)
+                anchors: (Array.isArray(r.candidateProvenance) ? r.candidateProvenance : [])
+                  .slice(0, 3).map((p) => (p && p.memoryId ? String(p.memoryId).slice(0, 12) : null))
+                  .filter(Boolean),
+                queryChars: r.queryChars || null, ts: r.ts || null,
+              }
+            } catch (e) { return { observationId: 'parse-error' } }
+          })
+          // G-02 v2(2026-08-30):决策↔投递时间线——把每条决策行与其真实投递结果关联。
+          // 投递面=证据事件里的 seen 簇(5s 内聚合成一次投递)∪ activation host 的 render
+          // 事件(volatile,含 skill 标志)。关联是启发式(时间窗+memoryId 交集),仅用于
+          // 可视化,不参与任何决策。完整 memoryId 只在服务端做交集,不出端点(v1 隐私口径)。
+          try {
+            const fullIdsByRow = all.slice(-24).map((l) => {
+              try { return (JSON.parse(l).candidateProvenance || []).map((p) => p && p.memoryId).filter(Boolean) } catch (_) { return [] }
+            })
+            const evDir2 = pathMod.join(dshHome(), 'memory', 'evidence', 'events')
+            const seenClusters = []
+            if (fsMod.existsSync(evDir2)) {
+              const raw = []
+              for (const f of fsMod.readdirSync(evDir2).filter((x) => x.endsWith('.jsonl')).slice(-2)) {
+                const lines = fsMod.readFileSync(pathMod.join(evDir2, f), 'utf8').split('\n').filter(Boolean)
+                for (const ln of lines.slice(-400)) {
+                  try { const r = JSON.parse(ln); if (r.kind === 'seen' && r.memoryId) raw.push({ at: Number((r.event && r.event.ts) || r.ts) || 0, memoryId: r.memoryId }) } catch (_) {}
+                }
+              }
+              raw.sort((a, b) => a.at - b.at)
+              for (const s of raw) {
+                const last = seenClusters[seenClusters.length - 1]
+                if (last && s.at - last.at <= 5000) last.memoryIds.push(s.memoryId)
+                else seenClusters.push({ at: s.at, memoryIds: [s.memoryId] })
+              }
+            }
+            let renderEvents = []
+            try {
+              const dv = engine._activationHost && engine._activationHost.debugView && engine._activationHost.debugView()
+              renderEvents = ((dv && dv.recentEvents) || []).filter((e) => e && e.kind === 'render')
+            } catch (_) {}
+            tail.forEach((row, i) => {
+              const ids = fullIdsByRow[i] || []
+              let delivery = null
+              // 只有关 deliverable 决策(emit/prefetch)才存在投递;取决策后最近的 seen 簇(≤300s)
+              if (row.ts && ids.length && (row.decision === 'emit' || row.decision === 'prefetch')) {
+                const tsMs = row.ts * 1000
+                let best = null
+                for (const c of seenClusters) {
+                  if (c.at < tsMs || c.at - tsMs > 300000) continue
+                  if (!c.memoryIds.some((m) => ids.includes(m))) continue
+                  if (!best || c.at < best.at) best = c
+                }
+                if (best) {
+                  const re = renderEvents.filter((e) => Math.abs(e.at - best.at) <= 15000).slice(-1)[0]
+                  delivery = { at: best.at, count: best.memoryIds.length, skill: !!(re && re.skill) }
+                }
+              }
+              row.delivery = delivery
+            })
+          } catch (_) {}
+          return writeJson(res, 200, { rows: tail })
+        } catch (e) { return writeJson(res, 500, { error: String(e && e.message) }) }
+      },
+    },
+    {
+      kind: 'exact',
+      path: API['review-feedback'],
+      handler: async (req, res) => {
+        // G-02 前置(append-only 审批队列;loopback):用户 A/P/S/H/E 判定落盘,不直接改任何策略。
+        // G-02 v2(2026-08-30)新增 GET:队列投影 + 判定×决策行联查汇总 + 政策提示(纯描述,
+        // 不改参数——政策演进仍走离线 replay/审批流程)。
+        if (!isLoopbackRequest(req)) return writeJson(res, 403, { error: 'forbidden: loopback-only' })
+        try {
+          const fsMod = await import('node:fs')
+          const pathMod = await import('node:path')
+          const dir = pathMod.join(dshHome(), 'memory', 'semantic')
+          const file = pathMod.join(dir, 'review-queue.jsonl')
+          if ((req.method || 'GET') === 'GET') {
+            let entries = []
+            if (fsMod.existsSync(file)) {
+              entries = fsMod.readFileSync(file, 'utf8').split('\n').filter(Boolean).slice(-100)
+                .map((l) => { try { return JSON.parse(l) } catch (_) { return null } }).filter(Boolean)
+            }
+            // 联查 shadow 决策行(observationId → 行摘要)
+            const shadowFile = pathMod.join(dir, 'activation-shadow-v2.jsonl')
+            const byObs = new Map()
+            if (fsMod.existsSync(shadowFile)) {
+              const lines = fsMod.readFileSync(shadowFile, 'utf8').split('\n').filter(Boolean)
+              for (const ln of lines.slice(-600)) {
+                try { const r = JSON.parse(ln); if (r.observationId && !byObs.has(r.observationId)) byObs.set(r.observationId, r) } catch (_) {}
+              }
+            }
+            const joined = entries.map((e) => {
+              const r = byObs.get(e.observationId)
+              const f = (r && r.features) || {}
+              return {
+                at: e.at, choice: e.choice, observationId: e.observationId,
+                decision: r ? r.decision : null, lane: (f && f.lane) || null,
+                intentProb: (f && f.intentProb) != null ? f.intentProb : null,
+                topReasons: r && Array.isArray(r.reasonCodes) ? r.reasonCodes.slice(0, 3) : [],
+              }
+            })
+            const byChoice = {}
+            for (const j of joined) byChoice[j.choice] = (byChoice[j.choice] || 0) + 1
+            const hints = []
+            for (const ch of ['H', 'S', 'E', 'A', 'P']) {
+              const group = joined.filter((j) => j.choice === ch)
+              if (!group.length) continue
+              const rc = {}
+              let hiConfidence = 0
+              for (const g of group) { for (const x of g.topReasons) rc[x] = (rc[x] || 0) + 1; if (g.decision === 'emit' && (g.intentProb || 0) >= 0.6) hiConfidence++ }
+              const topRc = Object.entries(rc).sort((a, b) => b[1] - a[1]).slice(0, 3).map((x) => x[0]).join(',')
+              if (ch === 'H' && group.some((g) => g.decision === 'emit')) hints.push('H 有害判定落在 emit 决策×' + group.filter((g) => g.decision === 'emit').length + '——建议复核对应 reasonCodes 的精确率: ' + topRc)
+              if (ch === 'S' && hiConfidence > 0) hints.push('S 应抑制判定命中高置信 emit(intentProb≥0.6)×' + hiConfidence + '——建议复核 explicit 车道 margin 阈值')
+              if (ch === 'A' && group.length >= 2) hints.push('A 该激活×' + group.length + '(常见原因码: ' + (topRc || '—') + ')——可作晋升采纳候选')
+            }
+            return writeJson(res, 200, { queue: joined.slice(-50), byChoice, hints })
+          }
+          if ((req.method || 'POST') !== 'POST') return writeJson(res, 405, { error: 'method not allowed' })
+          const body = await readJsonBody(req).catch(() => ({}))
+          const choice = String((body && body.choice) || '').toUpperCase()
+          if (!['A', 'P', 'S', 'H', 'E'].includes(choice)) return writeJson(res, 400, { error: 'invalid choice' })
+          fsMod.mkdirSync(dir, { recursive: true })
+          const rec = { schemaVersion: 1, at: Date.now(),
+            observationId: String((body && body.observationId) || '').slice(0, 64),
+            choice, targetMemoryId: String((body && body.targetMemoryId) || '').slice(0, 64) || null,
+            source: 'client-refine-panel' }
+          fsMod.appendFileSync(file, JSON.stringify(rec) + '\n', 'utf8')
+          return writeJson(res, 200, { ok: true, queued: true })
+        } catch (e) { return writeJson(res, 500, { error: String(e && e.message) }) }
+      },
+    },
+    {
+      kind: 'exact',
+      path: API['memory-hub'],
+      handler: async (req, res) => {
+        // M8 记忆中枢(loopback):GET 返回三层记忆 overview(episodic/facts/procedures);
+        // POST {action} 触发编排(consolidate=巩固会话 / feed=喂 judgement 行 / render=渲染 checklists)。
+        if (!isLoopbackRequest(req)) return writeJson(res, 403, { error: 'forbidden: loopback-only' })
+        try {
+          const hub = engine._memoryHub
+          if (!hub) return writeJson(res, 200, { error: 'hub-unavailable' })
+          if ((req.method || 'GET') === 'POST') {
+            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 === '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
+            // 对技能做晋升/激活/弃用/置顶。晋升走 store 的门槛判定(调门槛=设置页参数),
+            // 不绕过任何 gate;每次动作进 diagnose 审计。
+            const procs = hub.stores && hub.stores.procedures
+            const pid = String((body && body.procedureId) || '')
+            if (['promote', '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)
+              else if (action === 'activate') r = procs.activate(pid)
+              else if (action === 'deprecate') r = procs.deprecate(pid, 'user-disabled')
+              else r = procs.setPinned(pid, (body && body.v) !== false)
+              try { diag('hub review: ' + action + ' ' + pid.slice(0, 20) + ' → ' + JSON.stringify(r.ok !== undefined ? r.ok : r.decision || r.reason || '')) } catch (_) {}
+              return writeJson(res, 200, r)
+            }
+            return writeJson(res, 400, { error: 'unknown action' })
+          }
+          return writeJson(res, 200, hub.overview())
+        } catch (e) { return writeJson(res, 500, { error: String(e && e.message) }) }
+      },
+    },
+    {
+      kind: 'exact',
+      path: API['storage-manage'],
+      handler: async (req, res) => {
+        // M10 存储管理(loopback):GET=语料健康扫描(逐源 sidecar↔正文 digest 比对);
+        // POST {action:'scan'|'repair'|'delete'} —— repair 只重建 sidecar(不动正文),
+        // delete 走「正文原子删除 + 在途激活包清理 + 派生事实撤销」三联动。
+        if (!isLoopbackRequest(req)) return writeJson(res, 403, { error: 'forbidden: loopback-only' })
+        try {
+          const sm = engine._storageManager
+          if (!sm) return writeJson(res, 200, { error: 'storage-manager-unavailable' })
+          if ((req.method || 'GET') === 'POST') {
+            const body = await readJsonBody(req).catch(() => ({}))
+            const action = String((body && body.action) || '')
+            if (action === 'scan') return writeJson(res, 200, sm.scanHealth())
+            if (action === 'repair') return writeJson(res, 200, await sm.repair(Array.isArray(body.items) ? body.items : null))
+            if (action === 'delete') {
+              const filePath = String((body && body.filePath) || '')
+              const memoryId = String((body && body.memoryId) || '')
+              if (!filePath || !memoryId) return writeJson(res, 400, { error: 'filePath and memoryId required' })
+              // 路径白名单:只允许当前工作区三源之一,防止外部路径穿越
+              const sc = sm.scanHealth()
+              const allowed = sc.ok ? sc.sources.some((s) => s.file === filePath) : false
+              if (!allowed) return writeJson(res, 403, { error: 'path-not-in-corpus' })
+              const r = await sm.deleteMemory({ filePath, memoryId, expectedDigest: body && body.expectedDigest })
+              try { diag('storage-manage delete: ' + memoryId.slice(0, 20) + ' → ' + JSON.stringify(r.ok) + ' revoked=' + ((r.cascade && r.cascade.revoked && r.cascade.revoked.revoked) || 0)) } catch (_) {}
+              return writeJson(res, 200, r)
+            }
+            return writeJson(res, 400, { error: 'unknown action' })
+          }
+          return writeJson(res, 200, { ...sm.scanHealth(), audit: sm.auditLog().slice(-8) })
+        } catch (e) { return writeJson(res, 500, { error: String(e && e.message) }) }
+      },
+    },
+    {
+      kind: 'exact',
+      path: API['activation-inbox'],
+      handler: async (req, res) => {
+        // M6-3:fake activation 注入/状态(仅 loopback;activationInboxEnabled∧assoc 双门在 host 内再校验)
+        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 host = engine._activationHost
+          if (!host) return writeJson(res, 200, { error: 'host-unavailable' })
+          const action = String((body && body.action) || '')
+          if (action === 'inject') return writeJson(res, 200, host.injectActivation(body.request))
+          if (action === 'status') return writeJson(res, 200, { activationInbox: host.debugView() })
+          return writeJson(res, 400, { error: 'unknown action' })
+        } catch (e) { writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
+      },
+    },
     {
       kind: 'exact',
       path: API.state,
@@ -3120,7 +5343,11 @@ export function apply(ctx, config) {
             if (!body || typeof body !== 'object') return writeJson(res, 400, { error: 'invalid body' })
             const allowed = Object.keys(DEFAULT_CONFIG)
             const patch = {}
-            for (const key of allowed) if (body[key] !== undefined) patch[key] = body[key]
+            for (const key of allowed) if (body[key] !== undefined) {
+              // semanticEngineMode 枚举门:非法值直接丢弃(fail-closed,不落盘)
+              if (key === 'semanticEngineMode' && !['auto', 'lexical', 'js', 'python'].includes(body[key])) continue
+              patch[key] = body[key]
+            }
             const saved = await engine.saveConfig(patch)
             writeJson(res, 200, { config: saved.config, migrated: saved.migrated || '' })
             return
@@ -3296,13 +5523,46 @@ export function apply(ctx, config) {
         } catch (e) { writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
       },
     },
+    {
+      // 设置页「总结/问候默认模型」抽屉数据源:枚举 llm 服务全部 provider/model(只读目录)
+      kind: 'exact',
+      path: API.models,
+      handler: async (req, res) => {
+        if (!isLoopbackRequest(req)) return writeJson(res, 403, { error: 'forbidden: loopback-only' })
+        if ((req.method || 'GET') !== 'GET') return writeJson(res, 405, { error: 'method not allowed' })
+        try {
+          const llm = engine._llm
+          if (!llm || typeof llm.listProviders !== 'function' || typeof llm.listModels !== 'function') {
+            return writeJson(res, 200, { providers: [], failures: [], unsupported: true })
+          }
+          const providers = []
+          const failures = []
+          await Promise.all(llm.listProviders().map(async (provider) => {
+            const pid = provider && provider.id !== undefined ? String(provider.id) : String(provider)
+            const pname = provider && provider.name ? String(provider.name) : pid
+            try {
+              const models = await llm.listModels(pid)
+              providers.push({
+                id: pid,
+                name: pname,
+                models: (models || []).map((m2) => ({ id: m2 && m2.id !== undefined ? String(m2.id) : String(m2), name: m2 && m2.name ? String(m2.name) : undefined })),
+              })
+            } catch (e2) {
+              failures.push({ id: pid, name: pname, message: String(e2 && e2.message ? e2.message : e2) })
+            }
+          }))
+          providers.sort((a, b) => a.id.localeCompare(b.id))
+          writeJson(res, 200, { providers, failures })
+        } catch (e) { writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
+      },
+    },
   ]
 
   // ---------- 后台轮询兜底(对标外部助手的心跳轮询):每 5 分钟重试失败的自动沉淀 + 心跳文件 ----------
   // 心跳:每次轮询把存活状态写入 ~/.dsh/memory/polling-heartbeat.json(可随时查看 LastWriteTime 确认轮询活着)
   const writeHeartbeat = async () => {
     try {
-      const q = engine._pendingConsolidations || []
+      const q = engine.runtimes.values().reduce((sum, rt) => sum + rt.pendingConsolidations.length, 0)
       const hb = path.join(dshHome(), 'memory', 'polling-heartbeat.json')
       await mkdir(path.dirname(hb), { recursive: true })
       await writeFile(hb, JSON.stringify({
@@ -3318,10 +5578,11 @@ export function apply(ctx, config) {
   const retryTimer = setInterval(() => {
     void (async () => {
       try {
-        const q = engine._pendingConsolidations
-        if (q && q.length && !engine._consolidating) {
-          const item = q.shift()
-          if (item && item.agent) void engine.consolidateTurn(item.turn, item.agent)
+        for (const rt of engine.runtimes.values()) {
+          if (rt.pendingConsolidations.length && !rt.consolidating) {
+            const item = rt.pendingConsolidations.shift()
+            if (item && item.agent) void engine.withAgent(item.agent, () => engine.consolidateTurn(item.turn, item.agent))
+          }
         }
       } catch (e) {}
     })()
@@ -3332,8 +5593,28 @@ export function apply(ctx, config) {
 
   // ---------- 注册与清理 ----------
   const disposers = []
-  disposers.push(disposeContext, disposeSection)
-  for (const tool of tools) disposers.push(ctx.tools.register(tool))
+  disposers.push(disposeContext, disposeSection, () => {
+    try { if (engine._shadowHost) engine._shadowHost.disposeAll('plugin disposed') } catch (e) {}
+    try { if (engine._contextHost) engine._contextHost.disposeAll('plugin disposed') } catch (e) {}
+    try { if (engine._activationHost) engine._activationHost.disposeAll('plugin disposed') } catch (e) {}
+    try { if (engine._indexSyncHost) engine._indexSyncHost.dispose('plugin disposed') } catch (e) {}
+    try { if (engine._pythonSidecar) engine._pythonSidecar.dispose('plugin disposed') } catch (e) {}
+    // M8 hub:清定时器 + 落盘 dispose(各店 dispose 时 io.save 兜底)
+    try { if (engine._hubFeedDisposers) for (const d of engine._hubFeedDisposers) { try { d() } catch (_) {} } } catch (e) {}
+    try { if (engine._memoryHub) engine._memoryHub.dispose('plugin disposed') } catch (e) {}
+    try { engine.runtimes.disposeAll() } catch (e) {}
+  })
+  for (const tool of tools) {
+    // M0/M1: 工具执行绑定到其 agent 的 runtime(exec.agent 精确取 runtime),this.state/autoStats 读写不串线
+    const rawExec = tool.execute
+    if (typeof rawExec === 'function') {
+      tool.execute = async (args, exec) => {
+        const agent = exec && exec.agent
+        return agent ? engine.withAgent(agent, () => rawExec(args, exec)) : rawExec(args, exec)
+      }
+    }
+    disposers.push(ctx.tools.register(tool))
+  }
   for (const route of routes) disposers.push(ctx.webServer.register(route))
   ctx.effect(() => () => {
     clearInterval(retryTimer)