dsh-soul 0.7.2 → 0.8.0

package/index.mjs

@@ -29,13 +29,43 @@ import {
   LANGUAGE_VALUES,
   PERSONA_FIELDS,
   PERSONA_NAME_MAX,
+  PROMPT_INPUT_FIELDS,
   migrateConfig,
   sanitizeConfig,
   sanitizePersonaName
 } from './lib/config.mjs'
+import {
+  bindingsPathFor,
+  bindingRefusal,
+  compareKey,
+  MAX_BINDINGS,
+  MAX_PATH_LENGTH,
+  normalizeBindingEntry,
+  normalizeDirPath,
+  readBindingsFile,
+  resolveDirIdentity,
+  resolvePersonaForCwd,
+  writeBindingsFile
+} from './lib/bindings.mjs'
 import { createInjectionSource } from './lib/injection.mjs'
 import { isBuiltinPersona, builtinPersonaNames, mergePersonas, personaMatches, resolvePersona, declaredPersonaKeys } from './lib/personas.mjs'
 import { configWriteRefusal, describeConfigFailure, moveAsideConfigFile, readConfigFile, writeConfigFile } from './lib/store.mjs'
+import {
+  buildHistoryEntry,
+  clearHistoryFile,
+  createEntryId,
+  diffFields,
+  diffPersonas,
+  findEntryIndex,
+  hashConfig,
+  historyPathFor,
+  MAX_READ_LINES,
+  planRollback,
+  randomSuffix,
+  readHistoryFile,
+  recordHistoryEntry,
+  toHistoryResponse
+} from './lib/history.mjs'
 
 const name = 'soul'
 
@@ -44,6 +74,19 @@ function configPath() {
   return join(process.env.DSH_HOME || join(homedir(), '.dsh'), 'soul-config.json')
 }
 
+// 变更记录的落盘路径：配置文件的**兄弟文件**（soul-config.json → soul-config.history.jsonl）。
+// 与配置同目录而不塞进配置里，理由见 DESIGN-audit-rollback.md §4.1。
+function historyPath() {
+  return historyPathFor(configPath())
+}
+
+// 最近一次「变更记录没能记下来」的原因（记成功则清空）。
+//
+// 审计失败绝不能连带配置写失败 —— 那会把「记不下来」升级成「改不了」，
+// 而配置写入是这个插件的核心功能。但也不能装作没发生：原因经
+// GET /api/soul/history 的 warning 字段回传，设置页会原样显示。
+let lastHistoryFailure = null
+
 // 版本号：唯一来源是 package.json。
 //
 // 刻意**不**在这里再写一个常量 —— 需要手工同步的版本号已经有三处
@@ -371,26 +414,115 @@ function enqueueConfigWrite(task) {
   return run
 }
 
-// 纯客户端外观字段：变更它们不需要刷新系统提示词，也不需要向活动会话注入快照；
+// 不影响提示词的字段：变更它们不需要刷新系统提示词，也不需要向活动会话注入快照；
 // 但它们仍是实际配置变更，必须计入 changed（供调用方判断「已保存 / 无变化」并驱动前端 dirty）。
-const NON_PROMPT_FIELDS = new Set(['trailEnabled', 'trailColor', 'trailSpeed', 'trailWidth'])
+//
+// 由 DEFAULT_CONFIG 减去 PROMPT_INPUT_FIELDS **推导**，而不是手写清单。
+// 手写清单的代价已经发生过两次：trail* 四项之外，requireToolConfirmation 与
+// historyMaxEntries 都曾被漏在外面 —— 后果是改一次「保留条数」会重新注册 section
+// 并向所有活动会话注入一条配置更新消息，用户看到的是「我只调了个容量，Agent 却被
+// 通知了一遍配置变了」。这类「漏登记」不会报错，只会安静地多注入。
+//
+// 推导的安全前提是 compilePrompt 只读 PROMPT_INPUT_FIELDS 里的字段，该前提由
+// scripts/verify-config.mjs 的「编译源码读取的每个 config.X 都必须已登记」钉住。
+//
+// 未知键（不在 DEFAULT_CONFIG 里）会落在「影响提示词」一侧 —— 方向是安全的：
+// 最坏是多重启一次提示词，而不是改了不生效。
+const NON_PROMPT_FIELDS = new Set(
+  Object.keys(DEFAULT_CONFIG).filter((key) => !PROMPT_INPUT_FIELDS.includes(key))
+)
 
 // 在写队列中执行一次配置更新：mutate 收到当前配置的浅拷贝，返回新配置对象。
 // 注意 mutate 必须在队列任务内完成全部读取与合并，不要在队列外提前读取配置。
 // 返回 { config, changed, promptChanged }：
 //   - changed：实际发生变化的字段名数组（不含 personas 预设库），供调用方判断有无变更
 //   - promptChanged：changed 中会影响 Agent 行为的子集；为空时应跳过提示词刷新与会话注入
-async function commitConfig(mutate) {
+//
+// 第二参数 source 是**变更记录的归属**，形如 { source, action }：source 是渠道
+// （web / command / tool / service / persona / rollback / restorePersona），
+// action 是动作（save / set / use / …）。两个都是白名单枚举，写进条目与读回条目时各校验一次。
+//
+// 为什么必须由调用方显式给出：同一次「改了 style」可能是网页保存、斜杠命令、Agent 工具
+// 或其它插件调用，事后从配置差异里是**推不出来**的。审计的价值有一半在于回答
+// 「是谁改的」—— 默认值会让这半个价值静默消失，所以这里刻意不给默认值。
+async function commitConfig(mutate, source) {
   return enqueueConfigWrite(async () => {
     const current = await loadConfig()
-    const next = mutate({ ...current })
+    // mutate 允许返回 Promise：撤销要在「读记录 → 规划 → 写配置」之间保持原子，
+    // 而记录必须在**队列内**读。放在队列外读会有一个窗口——两次撤销并发时，
+    // 后者的规划建立在已被前者改过的配置上，指纹校验会给出看起来像「数据损坏」的
+    // diverged，排查方向完全跑偏。
+    const next = await mutate({ ...current })
     const changed = diffKeys(current, next)
     const promptChanged = changed.filter((key) => !NON_PROMPT_FIELDS.has(key))
     const config = await saveConfig(next)
-    return { config, changed, promptChanged }
+
+    // 差分必须在 saveConfig **之后**、且以它返回的配置为基准：saveConfig 会剔除
+    // tone / presets / examples 三个废弃字段，拿 mutate 的产物去比会把它们误报成变更。
+    const entry = await auditCommit(current, config, source, config.historyMaxEntries)
+
+    return { config, changed, promptChanged, entry }
   })
 }
 
+// 路由内主动拒绝：从队列任务里抛出即可中止本次提交（不写盘），由 handler 按状态码回话。
+// 不用返回一个「什么都没改」的配置来收场 —— 那会照样重写一次配置文件，
+// 让一次失败的操作在磁盘上留下痕迹。
+function httpError(status, message) {
+  const err = new Error(message)
+  err.httpStatus = status
+  return err
+}
+
+// 把一次成功的提交记进变更记录。
+//
+// 时机与失败处理（DESIGN-audit-rollback.md §5）：调用点已在 saveConfig 之后，
+// 所以「配置写失败却留下记录」在结构上不可能。反过来「配置已写、记录没写成」是可能的
+// （磁盘只读、记录文件被占用）—— 此时把原因记进 lastHistoryFailure 并**继续返回成功**，
+// 因为配置确实已经改了。
+async function auditCommit(current, config, source, maxEntries) {
+  try {
+    const fields = diffFields(current, config)
+    const personas = diffPersonas(current.personas, config.personas)
+
+    // 「什么都没变」必须在构造条目**之前**判掉，不能靠 buildHistoryEntry 返回 null 来表达。
+    // 后者把两种情况混成了同一个返回值：真的没变，和条目因为 shape 不对被拒
+    // （例如某个调用点漏标 source）—— 后者是代码缺陷，混进来就会变成
+    // 「配置改了、记录里没有、也没有任何告警」。这条判据把缺陷从静默变响亮。
+    const changedAny =
+      Object.keys(fields.after).length > 0 ||
+      personas.added.length > 0 || personas.updated.length > 0 || personas.removed.length > 0
+    if (!changedAny) {
+      lastHistoryFailure = null
+      return null
+    }
+
+    const entry = buildHistoryEntry({
+      id: createEntryId(Date.now(), randomSuffix()),
+      at: new Date().toISOString(),
+      source: source && source.source,
+      action: source && source.action,
+      label: source && source.label,
+      configHash: hashConfig(config),
+      before: fields.before,
+      after: fields.after,
+      personas
+    })
+    if (!entry) {
+      // 有变化却构造不出条目 ⇒ 一定是调用点的 source/action 没标或标错。
+      // 报出来而不是当作「无变化」跳过：审计缺一条而没人知道，比留一条错的更糟。
+      lastHistoryFailure = `变更记录条目构造失败（source=${JSON.stringify(source)}），本次改动未被记录`
+      return null
+    }
+    await recordHistoryEntry(historyPath(), entry, maxEntries)
+    lastHistoryFailure = null
+    return entry
+  } catch (err) {
+    lastHistoryFailure = String((err && err.message) || err)
+    return null
+  }
+}
+
 // 比较两份配置的差异字段名（浅比较；soul 配置为扁平对象）。
 // personas（人设预设库）不属于活动配置：库的增删改不应触发提示词刷新与会话注入。
 function diffKeys(a, b) {
@@ -420,13 +552,16 @@ function defaultConfigPreservingPersonas(current) {
 //
 // 复用 commitConfig 的「读—改—写」，不另写一份；写入失败时恢复失败标记，
 // 避免把「文件仍然不可用」误报成正常状态。
-async function resetConfigWithEscape() {
+//
+// source 由调用方给（web 重置 / 斜杠命令重置 / 其它插件调用），穿透给 commitConfig
+// 用于变更记录 —— 三个入口都是「重置」，但来源不同，记录里要分得开。
+async function resetConfigWithEscape(source) {
   const failure = configLoadFailure
   const backupPath = failure ? await moveAsideConfigFile(configPath()) : null
   if (failure) configLoadFailure = null
 
   try {
-    const result = await commitConfig((current) => defaultConfigPreservingPersonas(current))
+    const result = await commitConfig((current) => defaultConfigPreservingPersonas(current), source)
     return { ...result, backupPath }
   } catch (err) {
     if (failure) configLoadFailure = failure
@@ -587,14 +722,23 @@ function injectPromptToAllAgents(ctx, config) {
   }
 
   const T = promptTextOf(config)
-  const prompt = compilePrompt(config)
-  const snapshotText = prompt || T.injectDisabled
 
   let delivered = 0
   let failed = 0
   let lastError = null
 
   for (const agent of listed) {
+    // **每个会话各自编译**，不能共用一份文本。
+    //
+    // 工作区绑定让「配置」不再是全局唯一的：A 项目会话该拿到「资深架构师」，B 项目会话
+    // 该拿到「极简主义者」。若在这里算一份全局文本发给所有人，B 项目会收到 A 的人设 ——
+    // 这比不注入更糟（不注入时它至少还是全局配置，与用户以为的一致）。
+    //
+    // 拿不到 cwd（会话头无该字段）时 configForCwd 返回原配置，行为与绑定功能上线前一致。
+    const perAgent = configForCwd(config, cwdOfAgent(agent)).config
+    const prompt = compilePrompt(perAgent)
+    const snapshotText = prompt || T.injectDisabled
+
     try {
       agent.inject(createUserMessage({
         content: [{
@@ -643,6 +787,162 @@ function refreshPromptAndInject(ctx, config) {
   injectPromptToAllAgents(ctx, config)
 }
 
+// ==================== 工作区绑定：按目录解析人设 ====================
+//
+// 三层解析（DESIGN-persona-scope.md §5）：会话显式覆盖 → 目录绑定（最长前缀）→ 全局配置。
+// 0.8.1-b 落地的是中间那层；会话覆盖（0.8.1-c/d）尚未接入，接入点见 resolveForCwd 的注释。
+//
+// 为什么绑定表要单独缓存而不是每次读盘：本节的两个消费者都在**每一轮装配**上 ——
+// system prompt section 的 text provider 每轮都被调用一次，活动会话注入每次保存各一次。
+// 读盘 + 200 次 realpath 放进这条路径是不可接受的，所以绑定表在加载时规范化一次。
+
+// 绑定文件路径（configPath() 的兄弟文件）。
+function bindingsPath() {
+  return bindingsPathFor(configPath())
+}
+
+// 绑定表读数。null = 还没读过（与「读过了、确实是空表」必须分得开，
+// 后者意味着「用户一条都没绑」，前者意味着「还没问过磁盘」）。
+let bindingsCache = null
+
+// 最近一次绑定加载失败 / 有坏条目的说明（无问题为 null）。
+let bindingsLoadFailure = null
+
+// 命中判定的比较表。
+//
+// 这里有两个键集合，都指向同一条绑定：
+//   · **展示键**：绑定表里原样存着的形式，UI 与用户看到的就是它；
+//   · **身份键**：`realpath` 解析后的形式（解掉符号链接 / Junction；Windows 上还会
+//     规范化盘符大小写）。
+//
+// 为什么要两个都进比较表 —— 两边各自可能缺席一次解析：
+//   · 会话 cwd 由 Node 的 `process.cwd()` 提供（`GetCurrentDirectory` 返回的是**规范**
+//     路径），而绑定目录是用户在选择器里点出来的，很可能是 Junction 路径。
+//     典型失配：cwd = `D:\真实目录`、绑定键 = `D:\junction入口`。
+//   · 反过来，用户手工粘贴的路径可能本就是规范路径，而会话 cwd 落在 Junction 里。
+// 两个键都留着，任一侧成立即命中；`bindingsDisplayOf` 负责把命中结果翻译回展示键，
+// 因为用户不认得 realpath 吐出来的那个名字。
+//
+// **不对 cwd 做 realpath**：text provider 必须是**同步**的（见 registerSystemPrompt），
+// 而 realpath 是异步 I/O。把身份解析全部放在**键**侧，这个约束就消失了 ——
+// 键在加载时算一次，之后每轮装配都只是字符串比较。
+let bindingsCompareTable = null
+
+// 身份键 → 展示键（仅当两者不同时才有一条）。
+let bindingsDisplayOf = null
+
+// 解析绑定表：读盘 + 为每条键算出身份形态。
+//
+// 失败时**以空表继续**并把原因记在 bindingsLoadFailure 上，绝不抛错：
+// 绑定是可选增强，读不出来不该让整个插件的装配流程崩掉（与 loadConfig 的策略不同，
+// 因为配置是用户唯一的数据副本，而绑定不是）。
+//
+// 失败时**不写 bindingsCache**，与 loadConfig 同款：用户把文件改对之后，下一次
+// 加载（绑定路由写完表之后总会重新加载）就能自动恢复，不必重启 DSH。
+// 此时比较表被清成空表 —— 宁可暂时不生效，也不能拿上一次的旧表继续命中。
+async function loadBindings() {
+  const filePath = bindingsPath()
+  const { bindings, dropped, failure } = await readBindingsFile(filePath)
+  bindingsLoadFailure = failure || (dropped.length > 0 ? `${dropped.length} 条绑定因格式问题被忽略。` : null)
+
+  if (failure) {
+    bindingsCompareTable = {}
+    bindingsDisplayOf = new Map()
+    return { bindings: {}, dropped, failure, filePath }
+  }
+
+  // 计算身份键。并发发起（最多 MAX_BINDINGS=200 条，realpath 很轻），
+  // 但 resolveDirIdentity 自身绝不抛错，所以这里不需要 per-item 的 try/catch。
+  const compareTable = { ...bindings }
+  const displayOf = new Map()
+  const keys = Object.keys(bindings)
+  const identities = await Promise.all(keys.map(dir => resolveDirIdentity(dir)))
+
+  for (let i = 0; i < keys.length; i++) {
+    const dir = keys[i]
+    const identity = identities[i]
+    // 只有真的不同才加别键：同一条绑定占两个键位会让 shadowed 出现重复项。
+    if (!identity || compareKey(identity) === compareKey(dir)) continue
+    // 身份键撞上另一条展示键时**不覆盖** —— 展示键是用户亲手写的那个，
+    // 优先级更高；被挡住的身份键只是少一条别名，判定方向安全。
+    if (hasOwn(compareTable, identity)) continue
+    compareTable[identity] = bindings[dir]
+    displayOf.set(identity, dir)
+  }
+
+  bindingsCompareTable = compareTable
+  bindingsDisplayOf = displayOf
+  bindingsCache = { bindings, dropped, failure: null, filePath }
+  return bindingsCache
+}
+
+// 按目录解析该用什么人设（三层解析的「目录层」）。
+//
+// 返回 null 表示没有可用绑定 ⇒ 调用方回落全局配置（这是绝大多数用户的常态）。
+// 返回对象时：
+//   · dir / persona —— 真正生效的那条绑定；
+//   · shadowed —— 命中了、但人设已不存在的更具体绑定（不生效，但必须能说出来）。
+//
+// 本函数是**同步**的：它每轮装配都被调用，且 text provider 不允许是异步的。
+// 因此读盘只能发生在装配之外（apply() 启动时、绑定路由写完之后），见 ensureBindings。
+async function ensureBindings() {
+  if (!bindingsCache) await loadBindings()
+  return bindingsCache
+}
+
+function resolveBindingForCwd(cwd, userPersonas) {
+  if (!bindingsCompareTable || !bindingsDisplayOf) return null
+  const normalized = normalizeDirPath(cwd)
+  if (!normalized) return null
+
+  const resolved = resolvePersonaForCwd(normalized, bindingsCompareTable, userPersonas)
+  if (!resolved) return null
+
+  // 命中身份键时回报展示键（用户认得的是他自己写的那个名字）。
+  const display = dir => (bindingsDisplayOf.get(dir) || dir)
+  const seen = new Set()
+  const shadowed = []
+  for (const item of resolved.shadowed) {
+    const dir = display(item.dir)
+    // 同一条绑定的展示键与身份键可能都命中，去重后 UI 才不会把一条失效绑定画两遍。
+    if (seen.has(dir)) continue
+    seen.add(dir)
+    shadowed.push({ ...item, dir })
+  }
+
+  return { dir: display(resolved.dir), persona: resolved.persona, shadowed }
+}
+
+// 把「全局配置 + 一次目录解析结果」合成为该目录实际生效的配置。
+//
+// 用预设的**部分覆盖**语义（与 /api/soul/personas/use 同一条规则）：只覆盖条目实际
+// 声明过的字段，未声明的保持全局值。这条复用不是巧合 —— 用户在设置页点「使用」
+// 一个预设时看到的效果，必须与他在该目录里自动拿到的效果**逐字段一致**，
+// 否则「绑定生效了吗」将无法用任何已有操作来验证。
+//
+// `enabled` 刻意**不在**覆盖范围内（它不属于 PERSONA_FIELDS）：全局总开关始终说话，
+// 关掉插件后绑定的目录也不会偷偷注入人设。
+function configForCwd(base, cwd) {
+  const resolved = resolveBindingForCwd(cwd, base.personas)
+  if (!resolved) return { config: base, binding: null }
+  const persona = resolvePersona(resolved.persona, base.personas)
+  if (!persona) return { config: base, binding: null }
+  const { patch } = sanitizeConfig(pickPersonaValues(persona))
+  return { config: { ...base, ...patch }, binding: resolved }
+}
+
+// 从装配上下文里取该会话的工作目录。
+//
+// 两个都必须容忍 undefined：
+//   · `ctx` —— 宿主在 diagnostics 装配时**不传 agent**（runtime-types.d.ts:14-19 的注释
+//     写明 `absent on diagnostics`）。此时回落全局配置，绝不抛错。
+//   · `cwd` —— 会话头里可能没有这个字段。取不到时任何绑定都不会命中，
+//     于是行为与「没有绑定功能」完全一致（失败方向安全）。
+function cwdOfAgent(agent) {
+  const cwd = agent?.session?.header?.cwd
+  return typeof cwd === 'string' && cwd.trim() !== '' ? cwd : null
+}
+
 // ==================== HTTP 路由 ====================
 
 function registerRoutes(ctx) {
@@ -687,7 +987,7 @@ function registerRoutes(ctx) {
             }
 
             // 写队列内「读—改—写」，只合并通过校验的字段（未知字段不落盘）
-            const { config: updated, changed, promptChanged } = await commitConfig(current => ({ ...current, ...patch }))
+            const { config: updated, changed, promptChanged } = await commitConfig(current => ({ ...current, ...patch }), { source: 'web', action: 'save' })
 
             // 仅影响 Agent 行为的字段变化才刷新提示词并注入会话；
             // 光轨等纯外观字段只更新配置，不向会话堆积注入快照
@@ -800,7 +1100,7 @@ function registerRoutes(ctx) {
           // 经由逃生口：配置损坏时这是设置页唯一还能成功的写操作。
           // backupPath 非 null 说明刚才确实丢弃了一份损坏的配置（已备份），
           // 客户端据此给出「备份在哪」的提示，而不是让用户以为数据凭空消失。
-          const { config, changed, promptChanged, backupPath } = await resetConfigWithEscape()
+          const { config, changed, promptChanged, backupPath } = await resetConfigWithEscape({ source: 'web', action: 'reset' })
 
           // 仅影响 Agent 行为的字段变化才刷新提示词并注入会话
           if (promptChanged.length > 0) {
@@ -928,10 +1228,18 @@ function findActivePersonaName(config) {
 // 语义选择：应用**合法部分**并如实回报被丢弃的字段，而不是整单拒绝 —— 后者会让一个
 // 只差一个字段的旧预设彻底不可用，代价更高；而「部分应用 + 明示」与 /api/soul/prompt/
 // preview 的 invalid 约定一致。
+//
+// 来源固定为 persona/use：两个调用入口（网页「使用」与 /soul use）是同一个动作，
+// 用户视角下「用了个预设」这件事本身比「从哪个入口点的」更重要，故不细分。
 async function applyPersonaEntry(ctx, entry) {
   const { patch, errors } = sanitizeConfig(pickPersonaValues(entry))
   const invalid = Object.keys(errors)
-  const { config: updated, changed, promptChanged } = await commitConfig(c => ({ ...c, ...patch }))
+  // label 带上预设名：审计里「应用预设」这条记录光有字段差，缺「应用的是什么」——
+  // 用户问「昨晚我切到了哪个人设」时，字段差答不上来。
+  const { config: updated, changed, promptChanged } = await commitConfig(
+    c => ({ ...c, ...patch }),
+    { source: 'persona', action: 'use', label: entry && typeof entry.name === 'string' ? entry.name : undefined }
+  )
   if (promptChanged.length > 0) refreshPromptAndInject(ctx, updated)
   // applied 是「通过校验的字段数」——与 changed（实际产生差异的字段）不同：
   // 全部非法时 applied 为 0，此时不能报「已应用」，也不能报「与当前配置一致」。
@@ -1001,7 +1309,7 @@ function registerPersonaRoutes(ctx) {
             const personas = clonePersonas(current.personas)
             personas[personaName] = { ...personaSnapshotOf(current), updatedAt: new Date().toISOString() }
             return { ...current, personas }
-          })
+          }, { source: 'web', action: 'savePreset' })
           send(res, 200, { ok: true, ...personaLibrary(updated) })
         } catch (err) {
           send(res, 500, { ok: false, error: String(err.message || err) })
@@ -1080,7 +1388,7 @@ function registerPersonaRoutes(ctx) {
             const personas = clonePersonas(c.personas)
             delete personas[personaName]
             return { ...c, personas }
-          })
+          }, { source: 'web', action: 'deletePreset' })
           send(res, 200, { ok: true, ...personaLibrary(updated) })
         } catch (err) {
           send(res, 500, { ok: false, error: String(err.message || err) })
@@ -1129,6 +1437,456 @@ function registerPersonaRoutes(ctx) {
   })
 }
 
+// ==================== 变更记录 ====================
+
+// 解析 ?limit=。非法值一律当作「没给」而不是报错：这是一个纯展示参数，
+// 为一个拼错的查询串返回 400 只会让客户端多写一段没必要的错误处理。
+function parseLimit(rawUrl) {
+  try {
+    const raw = new URL(String(rawUrl || ''), 'http://localhost').searchParams.get('limit')
+    if (raw === null) return null
+    const value = Number.parseInt(raw, 10)
+    if (!Number.isFinite(value) || value <= 0) return null
+    return Math.min(value, MAX_READ_LINES)
+  } catch {
+    return null
+  }
+}
+
+// 变更记录的四条路由：列表 / 撤销 / 恢复预设 / 清空。
+//
+// 一律先校验 req.method（同文件其余写路由的规矩，来自 /api/soul/config/reset
+// 曾经任何方法——包括 GET——都能触发破坏性写入的教训）。
+//
+// 撤销与恢复预设都走唯一漏斗 commitConfig，于是「我撤销过一次」本身也留下一条记录：
+// 审计因此是链条而不是快照，能看出「改了、撤了、又改回去」。
+function registerHistoryRoutes(ctx) {
+  ctx.inject(['webServer'], (wsCtx) => {
+    const send = (res, status, body) => {
+      res.writeHead(status, { 'content-type': 'application/json' })
+      res.end(JSON.stringify(body))
+    }
+
+    // 列表（最新在前）
+    wsCtx.webServer.register({
+      kind: 'exact',
+      path: '/api/soul/history',
+      handler: async (req, res) => {
+        try {
+          if (req.method !== 'GET') {
+            send(res, 405, { ok: false, error: 'Method not allowed' })
+            return
+          }
+          const read = await readHistoryFile(historyPath())
+          // max 必须来自**当前配置**（用户改了保留条数，UI 的「最多保留 N 条」就得跟着变）；
+          // 读配置失败时回退默认值 —— 列表读取不该因为配置层的抖动而 500。
+          let maxEntries
+          try {
+            maxEntries = (await loadConfig()).historyMaxEntries
+          } catch {
+            maxEntries = undefined
+          }
+          const payload = toHistoryResponse(read, lastHistoryFailure, maxEntries)
+          // ?limit= 只影响本次返回的条数，**不动 max** —— max 是容量上限（压实后保多少条），
+          // 拿它当「本次有多少条」用，客户端会在两种含义之间猜。
+          const limit = parseLimit(req.url)
+          if (limit !== null && payload.entries.length > limit) {
+            payload.entries = payload.entries.slice(0, limit)
+          }
+          send(res, 200, { ok: true, ...payload })
+        } catch (err) {
+          send(res, 500, { ok: false, error: String(err.message || err) })
+        }
+      }
+    })
+
+    // 撤销：把配置退回到目标条目**发生之前**的状态（连带撤销它之后的所有改动）
+    wsCtx.webServer.register({
+      kind: 'exact',
+      path: '/api/soul/history/rollback',
+      handler: async (req, res) => {
+        try {
+          if (req.method !== 'POST') {
+            send(res, 405, { ok: false, error: 'Method not allowed' })
+            return
+          }
+          const parsed = await readJsonBody(req)
+          if (!parsed.ok) {
+            send(res, parsed.status, { ok: false, error: parsed.error })
+            return
+          }
+          const id = typeof (parsed.body && parsed.body.id) === 'string' ? parsed.body.id : ''
+          if (!id) {
+            send(res, 400, { ok: false, error: '缺少要撤销的记录 id' })
+            return
+          }
+
+          let plan = null
+          const { config: updated, changed, promptChanged, entry } = await commitConfig(async (current) => {
+            // 记录必须在**队列内**读：放到队列外读会与并发写入形成窗口，规划建立在
+            // 已被别人改过的配置上，指纹校验随后报出一个看起来像「数据损坏」的
+            // diverged，把排查方向带偏。
+            const read = await readHistoryFile(historyPath())
+            if (read.error) throw httpError(500, read.error)
+            plan = planRollback(read.entries, current, id)
+            if (!plan.ok) {
+              if (plan.reason === 'missing') {
+                throw httpError(400, `找不到这条变更记录：${id}。它可能已被清空或压实淘汰。`)
+              }
+              // diverged：配置与记录不同步（有人手改过配置文件）。不给一个猜出来的结果。
+              throw httpError(409, '记录与当前配置对不上，无法撤销。可能有人手工改过配置文件。')
+            }
+            // 补丁为空是**合法**结果（目标那次改动已被后续改动改回来了），
+            // 此时不改任何字段、也不会留下记录，由 unchanged 告诉客户端「已经是最新」。
+            if (Object.keys(plan.patch).length === 0) return { ...current }
+            return { ...current, ...plan.patch }
+          }, { source: 'rollback', action: 'rollback' })
+
+          // 仅影响 Agent 行为的字段变化才刷新提示词注入（与其余写路径同一门控）
+          if (promptChanged.length > 0) refreshPromptAndInject(ctx, updated)
+
+          send(res, 200, {
+            ok: true,
+            config: updated,
+            changed,
+            skipped: plan ? plan.skipped : [],
+            reversed: plan ? plan.reversed : [],
+            unchanged: changed.length === 0,
+            entry,
+            deliveryWarning: deliveryProblemText(updated)
+          })
+        } catch (err) {
+          const status = err && err.httpStatus ? err.httpStatus : 500
+          send(res, status, { ok: false, error: String((err && err.message) || err) })
+        }
+      }
+    })
+
+    // 恢复预设：只对「删除预设」这类条目有意义（条目里带着被删条目的内容）
+    wsCtx.webServer.register({
+      kind: 'exact',
+      path: '/api/soul/history/restore-persona',
+      handler: async (req, res) => {
+        try {
+          if (req.method !== 'POST') {
+            send(res, 405, { ok: false, error: 'Method not allowed' })
+            return
+          }
+          const parsed = await readJsonBody(req)
+          if (!parsed.ok) {
+            send(res, parsed.status, { ok: false, error: parsed.error })
+            return
+          }
+          const id = typeof (parsed.body && parsed.body.id) === 'string' ? parsed.body.id : ''
+          if (!id) {
+            send(res, 400, { ok: false, error: '缺少记录 id' })
+            return
+          }
+
+          const restored = []
+          const skipped = []
+          const { config: updated, changed, entry } = await commitConfig(async (current) => {
+            const read = await readHistoryFile(historyPath())
+            if (read.error) throw httpError(500, read.error)
+            const index = findEntryIndex(read.entries, id)
+            if (index < 0) {
+              throw httpError(400, `找不到这条变更记录：${id}。它可能已被清空或压实淘汰。`)
+            }
+            const removed = read.entries[index].personas.removed
+            if (removed.length === 0) {
+              throw httpError(400, '这条记录里没有被删除的预设，无法恢复。')
+            }
+            const personas = clonePersonas(current.personas)
+            for (const item of removed) {
+              // 逐个校验、逐个说明为什么没恢复。**绝不静默覆盖同名条目**：
+              // 删掉「架构师」之后完全可能又新建了一个同名但内容不同的预设，
+              // 此时「恢复」若是直接写回，等于把用户后来的编辑悄悄扔掉。
+              const personaName = sanitizePersonaName(item.name)
+              if (!personaName) {
+                skipped.push({ name: item.name, reason: 'invalid-name' })
+                continue
+              }
+              if (isBuiltinPersona(personaName)) {
+                skipped.push({ name: personaName, reason: 'builtin' })
+                continue
+              }
+              if (hasOwn(personas, personaName)) {
+                skipped.push({ name: personaName, reason: 'exists' })
+                continue
+              }
+              personas[personaName] = { ...item.entry }
+              restored.push(personaName)
+            }
+            if (restored.length === 0) {
+              throw httpError(400, `没有可恢复的预设：${skipped.map((item) => item.name).join('、')}`)
+            }
+            return { ...current, personas }
+          }, { source: 'restorePersona', action: 'restorePreset' })
+
+          // 预设库变化不触发会话注入（diffKeys 本就跳过 personas），故此处不刷新提示词
+          send(res, 200, { ok: true, restored, skipped, changed, entry, ...personaLibrary(updated) })
+        } catch (err) {
+          const status = err && err.httpStatus ? err.httpStatus : 500
+          send(res, status, { ok: false, error: String((err && err.message) || err) })
+        }
+      }
+    })
+
+    // 清空：隐私出口（记录里有昵称 / 职业 / 介绍 / 自定义指令的原文）
+    wsCtx.webServer.register({
+      kind: 'exact',
+      path: '/api/soul/history/clear',
+      handler: async (req, res) => {
+        try {
+          if (req.method !== 'POST') {
+            send(res, 405, { ok: false, error: 'Method not allowed' })
+            return
+          }
+          // 借配置写队列串行：记录是在提交路径里写的，清空若不入队就会与并发的追加
+          // 撞在一起 —— 最坏的结果是「刚清完又冒出一条」，用户会以为清空没生效。
+          const removed = await enqueueConfigWrite(async () => {
+            const count = await clearHistoryFile(historyPath())
+            lastHistoryFailure = null
+            return count
+          })
+          send(res, 200, { ok: true, removed })
+        } catch (err) {
+          send(res, 500, { ok: false, error: String(err.message || err) })
+        }
+      }
+    })
+  })
+}
+
+// ==================== 工作区绑定路由 ====================
+
+// 绑定表的写队列。与配置队列（enqueueConfigWrite）**刻意是两个实例**（设计 §4.3）：
+// 两套数据在因果上无关 —— 绑定的写入不依赖配置的当前值，反之亦然 —— 共用一个队列
+// 只会把两者的延迟叠在一起，一次慢写的绑定请求会挡住配置保存。
+let bindingsWriteQueue = Promise.resolve()
+
+function enqueueBindingsWrite(task) {
+  const run = bindingsWriteQueue.then(task)
+  bindingsWriteQueue = run.then(() => {}, () => {})
+  return run
+}
+
+// 活动会话的目录与解析结果，供设置页回答「我这个项目现在是谁」。
+//
+// 为什么必须由宿主算：设置页的槽位 scope 是 `root`（设计 §7.7），它**拿不到
+// sessionId**，也就拿不到会话 cwd。宿主遍历 agents.list() 是唯一权威的来源。
+//
+// 取 `session.header.cwd` 而不是工作区根：两者可能不同（工作区 D:\AliuProject、
+// 会话 cwd D:\AliuProject\dsh-plugin），显示错粒度会让用户绑错层级。
+function describeActiveSessions(ctx, config) {
+  const out = []
+  const agents = ctx.get('agents')
+  if (!agents || typeof agents.list !== 'function') return out
+
+  let listed
+  try {
+    listed = agents.list()
+  } catch {
+    // 列不出活动会话不是错误：设置页只是少一段「当前用的谁」，仍能管理绑定表。
+    return out
+  }
+
+  for (const agent of listed) {
+    const cwd = cwdOfAgent(agent)
+    const id = agent && typeof agent.id === 'string' ? agent.id : null
+
+    if (!cwd) {
+      // cwd 缺席是宿主允许的情况（会话没有工作目录）。必须如实说出来 ——
+      // 让用户对着空白猜「为什么绑了没生效」，不如直接告诉他这个会话没有目录。
+      out.push({ id, cwd: null, persona: findActivePersonaName(config), binding: null, shadowed: [] })
+      continue
+    }
+
+    const resolved = resolveBindingForCwd(cwd, config.personas)
+    // 生效人设走与真实装配**同一条路径**（configForCwd → 部分覆盖 → findActivePersonaName），
+    // 否则设置页显示的「生效人设」与实际注入的可能不一致 —— 那正是最难查的一类 bug。
+    const effective = configForCwd(config, cwd).config
+
+    let binding = null
+    if (resolved) {
+      // 「直接绑定」与「继承自上级」的判别**必须在宿主做**：客户端拿原始串比较时，
+      // Windows 上 `D:\项目A` 与 `d:\项目a` 会被判成不同目录，于是「就是本目录」
+      // 被显示成「继承自上级」，用户会去找一条并不存在的父级绑定。
+      const sameDir = compareKey(normalizeDirPath(resolved.dir)) === compareKey(normalizeDirPath(cwd))
+      binding = { dir: resolved.dir, persona: resolved.persona, inherited: !sameDir }
+    }
+
+    out.push({
+      id,
+      cwd,
+      persona: findActivePersonaName(effective),
+      binding,
+      shadowed: resolved ? resolved.shadowed : []
+    })
+  }
+
+  return out
+}
+
+// 绑定表的可读形态（列表 + 失效标注 + 解析结果）。
+async function bindingsView(ctx) {
+  const cache = await ensureBindings()
+  const config = await loadConfig()
+
+  // 失效引用：指向的人设已不存在。**不自动删除**（设计 §4.2）——用户可能只是临时
+  // 删了那个预设、打算重命名回来。但必须显式标注，否则用户在目录里等一个永远
+  // 不会来的人设。
+  const invalid = []
+  for (const dir of Object.keys(cache.bindings)) {
+    const name = cache.bindings[dir]
+    if (!resolvePersona(name, config.personas)) invalid.push({ dir, persona: name })
+  }
+
+  return {
+    bindings: cache.bindings,
+    invalid,
+    dropped: cache.dropped,
+    // warning 是「整表没读进来」或「有条目被丢弃」，与「一条都没绑」是两件事。
+    warning: bindingsLoadFailure,
+    max: MAX_BINDINGS,
+    maxPathLength: MAX_PATH_LENGTH,
+    sessions: describeActiveSessions(ctx, config)
+  }
+}
+
+function registerBindingRoutes(ctx) {
+  ctx.inject(['webServer'], (wsCtx) => {
+    const send = (res, status, body) => {
+      res.writeHead(status, { 'content-type': 'application/json' })
+      res.end(JSON.stringify(body))
+    }
+
+    // 写完之后统一收尾：重载绑定表 → 刷新提示词并注入。
+    //
+    // 这是**第三类**会改变提示词的事实（设计 §6.4）：它不改 soul-config.json，
+    // 所以 commitConfig 的 promptChanged 门控看不见它。绑定路由必须自己触发，
+    // 否则「刚绑好，会话里却不生效，要新开会话才行」。
+    const afterBindingsWrite = async (config) => {
+      await loadBindings()
+      const fresh = config || (await loadConfig())
+      refreshPromptAndInject(ctx, fresh)
+    }
+
+    // GET = 读取（绑定表 + 当前活动会话的解析结果）；POST = 新增 / 改绑。
+    //
+    // 同一 (kind, path) 只能 register **一次**：宿主 dsh-host-webserver 的
+    // `register()` 对重复路径直接 `throw new Error('webserver: duplicate exact
+    // route "' + path + '"')`，而这里是 ctx.inject 回调 —— 一次重复注册会让
+    // 整个插件装配失败。故方法分派必须写在 handler 内，这也正是本文件其余
+    // 14 条路由的范式。
+    wsCtx.webServer.register({
+      kind: 'exact',
+      path: '/api/soul/bindings',
+      handler: async (req, res) => {
+        if (req.method === 'GET') {
+          try {
+            send(res, 200, { ok: true, ...(await bindingsView(ctx)) })
+          } catch (err) {
+            send(res, 500, { ok: false, error: String(err.message || err) })
+          }
+          return
+        }
+        if (req.method !== 'POST') {
+          send(res, 405, { ok: false, error: 'Method not allowed' })
+          return
+        }
+        try {
+          const parsed = await readJsonBody(req)
+          if (!parsed.ok) {
+            send(res, parsed.status, { ok: false, error: parsed.error })
+            return
+          }
+
+          const config = await loadConfig()
+          // 准入检查挑出三类拒绝（路径非法 / 过长 / 人设不存在），
+          // 原因文案可直接展示 —— 客户端不得再包一层前缀。
+          const refusal = bindingRefusal(parsed.body && parsed.body.dir, parsed.body && parsed.body.persona, config.personas)
+          if (refusal) {
+            send(res, 400, { ok: false, error: refusal })
+            return
+          }
+          const entry = normalizeBindingEntry(parsed.body && parsed.body.dir, parsed.body && parsed.body.persona, config.personas)
+          if (!entry) {
+            send(res, 400, { ok: false, error: '绑定内容不合法，未写入。' })
+            return
+          }
+
+          await enqueueBindingsWrite(async () => {
+            // 队列内读盘再合并：队列外读会与并发写入形成窗口，后写覆盖前写。
+            const read = await readBindingsFile(bindingsPath())
+            if (read.failure) throw httpError(500, read.failure)
+            const table = { ...read.bindings }
+            // 已存在的目录改绑不算新增，只有真新增才受条数上限约束 ——
+            // 否则满表之后连改绑都做不了，用户只能先删再绑。
+            const isNew = !hasOwn(table, entry.dir)
+            if (isNew && Object.keys(table).length >= MAX_BINDINGS) {
+              throw httpError(400, `绑定数量已达上限（${MAX_BINDINGS} 条），请先删除不再需要的绑定。`)
+            }
+            table[entry.dir] = entry.persona
+            await writeBindingsFile(bindingsPath(), table)
+          })
+
+          await afterBindingsWrite(config)
+          send(res, 200, { ok: true, ...(await bindingsView(ctx)) })
+        } catch (err) {
+          // 队列内抛出的 httpError 带状态码；其余按 500 处理。
+          send(res, err.httpStatus || 500, { ok: false, error: String(err.message || err) })
+        }
+      }
+    })
+
+    // 解绑
+    wsCtx.webServer.register({
+      kind: 'exact',
+      path: '/api/soul/bindings/delete',
+      handler: async (req, res) => {
+        try {
+          if (req.method !== 'POST') {
+            send(res, 405, { ok: false, error: 'Method not allowed' })
+            return
+          }
+          const parsed = await readJsonBody(req)
+          if (!parsed.ok) {
+            send(res, parsed.status, { ok: false, error: parsed.error })
+            return
+          }
+          const target = normalizeDirPath(parsed.body && parsed.body.dir)
+          if (!target) {
+            send(res, 400, { ok: false, error: '需要一个绝对路径才能解绑。' })
+            return
+          }
+
+          const config = await loadConfig()
+          let removed = false
+          await enqueueBindingsWrite(async () => {
+            const read = await readBindingsFile(bindingsPath())
+            if (read.failure) throw httpError(500, read.failure)
+            const table = { ...read.bindings }
+            // 按**比较键**找：用户点了列表里那一行，但配置里存的可能是另一种写法
+            // （分隔符、尾分隔符、盘符大小写）。拿原串直接 delete 会「点了没反应」。
+            const key = Object.keys(table).find(dir => compareKey(dir) === compareKey(target))
+            if (key === undefined) return
+            delete table[key]
+            removed = true
+            await writeBindingsFile(bindingsPath(), table)
+          })
+
+          // 没删掉任何东西时**不刷新**：一次空解绑不该向所有活动会话注入快照。
+          if (removed) await afterBindingsWrite(config)
+          send(res, 200, { ok: true, removed, ...(await bindingsView(ctx)) })
+        } catch (err) {
+          send(res, err.httpStatus || 500, { ok: false, error: String(err.message || err) })
+        }
+      }
+    })
+  })
+}
+
 // ==================== 斜杠命令 ====================
 
 // 宿主端无 locale 服务（CommandInvocation 不携带 UI 语言，settings 中亦无语言字段），
@@ -1383,7 +2141,7 @@ function registerCommands(ctx) {
             if (errors.nickname) {
               return { kind: 'error', text: t.failed(errors.nickname) }
             }
-            const { config: updated, promptChanged } = await commitConfig(c => ({ ...c, nickname: patch.nickname }))
+            const { config: updated, promptChanged } = await commitConfig(c => ({ ...c, nickname: patch.nickname }), { source: 'command', action: 'nickname' })
             if (promptChanged.length > 0) refreshPromptAndInject(ctx, updated)
             return { kind: 'success', text: t.nicknameDone(patch.nickname) }
           }
@@ -1427,7 +2185,7 @@ function registerCommands(ctx) {
           if (first === 'reset') {
             // 重置活动配置，但保留人设预设库。
             // 经由逃生口：配置损坏时这是唯一还能落盘的操作（先备份损坏文件）。
-            const { config: updated, promptChanged, backupPath } = await resetConfigWithEscape()
+            const { config: updated, promptChanged, backupPath } = await resetConfigWithEscape({ source: 'command', action: 'reset' })
             if (promptChanged.length > 0) refreshPromptAndInject(ctx, updated)
             return backupPath
               ? { kind: 'success', text: t.resetRecovered(backupPath) }
@@ -1436,13 +2194,13 @@ function registerCommands(ctx) {
 
           if (first === 'enable') {
             // 写队列内「读—改—写」，不在队列外改写内存缓存对象；无变化时跳过注入
-            const { config: updated, promptChanged } = await commitConfig(c => ({ ...c, enabled: true }))
+            const { config: updated, promptChanged } = await commitConfig(c => ({ ...c, enabled: true }), { source: 'command', action: 'enable' })
             if (promptChanged.length > 0) refreshPromptAndInject(ctx, updated)
             return { kind: 'success', text: t.enableDone }
           }
 
           if (first === 'disable') {
-            const { config: updated, promptChanged } = await commitConfig(c => ({ ...c, enabled: false }))
+            const { config: updated, promptChanged } = await commitConfig(c => ({ ...c, enabled: false }), { source: 'command', action: 'disable' })
             if (promptChanged.length > 0) refreshPromptAndInject(ctx, updated)
             return { kind: 'success', text: t.disableDone }
           }
@@ -1457,7 +2215,7 @@ function registerCommands(ctx) {
               const personas = clonePersonas(current.personas)
               personas[personaName] = { ...personaSnapshotOf(current), updatedAt: new Date().toISOString() }
               return { ...current, personas }
-            })
+            }, { source: 'command', action: 'savePreset' })
             return { kind: 'success', text: t.saveDone(personaName) }
           }
 
@@ -1521,7 +2279,7 @@ function registerCommands(ctx) {
               const personas = clonePersonas(current.personas)
               delete personas[personaName]
               return { ...current, personas }
-            })
+            }, { source: 'command', action: 'deletePreset' })
             return { kind: 'success', text: t.delDone(personaName) }
           }
 
@@ -1555,7 +2313,7 @@ function registerCommands(ctx) {
             if (Object.keys(patch).length === 0) {
               return { kind: 'error', text: t.failed(droppedKeys.length > 0 ? `${t.unknownField}: ${droppedKeys.join(', ')}` : t.setUsage) }
             }
-            const { config: updated, changed, promptChanged } = await commitConfig(c => ({ ...c, ...patch }))
+            const { config: updated, changed, promptChanged } = await commitConfig(c => ({ ...c, ...patch }), { source: 'command', action: 'set' })
             if (promptChanged.length > 0) refreshPromptAndInject(ctx, updated)
             return { kind: 'success', text: changed.length > 0 ? t.setDone(changed) : t.setNoChanges }
           }
@@ -1564,7 +2322,7 @@ function registerCommands(ctx) {
             if (!pendingPersonaProposal) return { kind: 'error', text: t.noPending }
             const proposal = pendingPersonaProposal
             pendingPersonaProposal = null
-            const { config: updated, changed, promptChanged } = await commitConfig(c => ({ ...c, ...proposal.patch }))
+            const { config: updated, changed, promptChanged } = await commitConfig(c => ({ ...c, ...proposal.patch }), { source: 'command', action: 'confirm' })
             if (promptChanged.length > 0) refreshPromptAndInject(ctx, updated)
             const detail = Object.keys(proposal.patch).map((key) => `${key}=${JSON.stringify(proposal.patch[key])}`).join(', ')
             return { kind: 'success', text: t.confirmDone(detail) }
@@ -1619,7 +2377,17 @@ function registerSystemPrompt(ctx) {
         // 代价为 0：我们不使用任何宿主提示词变量（需要上下文时，text 本身就是
         // provider）。关掉它同时让「预览所见」与「真实注入」逐字符一致。
         interpolate: false,
-        text: () => compilePrompt(configCache || DEFAULT_CONFIG)
+        text: (assembly) => {
+          // ⚠️ 必须同步：宿主以 `section.text(context)` 的形式**同步**调用
+          // （dsh-system-prompt 的装配：`typeof entry.text === 'function' ? entry.text(context) : entry.text`），
+          // 返回 Promise 会被当成 section 文本对象塞进提示词。所以这里只做纯字符串
+          // 比较——路径的身份解析（realpath）已在 loadBindings() 里对**键**做过一次。
+          //
+          // `assembly.agent` 在诊断装配时缺席（宿主注释写明 `absent on diagnostics`），
+          // cwdOfAgent 对 undefined 返回 null ⇒ configForCwd 原样返回全局配置。
+          const base = configCache || DEFAULT_CONFIG
+          return compilePrompt(configForCwd(base, cwdOfAgent(assembly && assembly.agent)).config)
+        }
       })
 
       deliveryState.sectionRegisteredAt = new Date().toISOString()
@@ -1930,7 +2698,7 @@ function registerTools(ctx) {
                 next[key] = patch[key]
               }
               return next
-            })
+            }, { source: 'tool', action: 'setPersona' })
 
             if (changed.length === 0) {
               return { ok: true, message: promptTextOf(updated).toolNoChanges }
@@ -1958,6 +2726,13 @@ function registerTools(ctx) {
 export async function apply(ctx) {
   // 加载配置
   await loadConfig()
+
+  // 加载工作区绑定表。
+  //
+  // 必须在装配路径之外做完：system prompt section 的 text provider 是**同步**的
+  // （见 registerSystemPrompt 里的说明），不能在里面 await 读盘。这里读一次，
+  // 之后每轮装配只做纯字符串比较。失败不阻塞启动（绑定是可选增强）。
+  await ensureBindings()
   
   // 提供 soulConfig 服务
   ctx.provide('soulConfig', {
@@ -1970,7 +2745,7 @@ export async function apply(ctx) {
       if (Object.keys(errors).length > 0) {
         throw new Error('配置校验失败：' + formatFieldErrors(errors))
       }
-      const { config, promptChanged } = await commitConfig(current => ({ ...current, ...patch }))
+      const { config, promptChanged } = await commitConfig(current => ({ ...current, ...patch }), { source: 'service', action: 'update' })
       // 送达与另外三条写路径保持一致：服务调用方（其它插件）改配置后同样应当
       // 立即反映到活动会话，否则「改了配置不生效」会从服务这条路再次出现。
       if (promptChanged.length > 0) refreshPromptAndInject(ctx, config)
@@ -1982,7 +2757,7 @@ export async function apply(ctx) {
     },
     async resetConfig() {
       // 与 HTTP / 斜杠命令两条重置入口共用逃生口
-      const { config, promptChanged } = await resetConfigWithEscape()
+      const { config, promptChanged } = await resetConfigWithEscape({ source: 'service', action: 'reset' })
       if (promptChanged.length > 0) refreshPromptAndInject(ctx, config)
       return config
     }
@@ -1991,6 +2766,8 @@ export async function apply(ctx) {
   // 注册各模块
   registerRoutes(ctx)
   registerPersonaRoutes(ctx)
+  registerHistoryRoutes(ctx)
+  registerBindingRoutes(ctx)
   registerCommands(ctx)
   registerSystemPrompt(ctx)
   registerTools(ctx)