dsh-config-manager 0.1.72 → 0.1.76

package/src/core/rollback.ts

@@ -7,7 +7,7 @@
  *    如实标记 failed + manualHint（人工补录）；
  *  - settings 回滚仍走 expectedRevision 乐观锁，避免覆盖导入后用户的新修改。
  */
-import { resolveFileTarget } from './backup.ts';
+import { fsForSection, resolveFileTarget } from './backup.ts';
 import { isPatchLayerRel, USER_PATCH_FILE } from './patch-layers.ts';
 import { msgOf } from './messages.ts';
 import type {
@@ -88,13 +88,15 @@ async function compensateOne(
     }
     case 'file': {
       try {
+        // 门面按分区选（pluginData / pluginAssets 在系统 home 根；见 backup.ts 的 fsForSection）
+        const fsFacade = fsForSection(ctx, entry.adapter);
         const abs = resolveFileTarget(ctx, entry.adapter, entry.ref);
         if (entry.existed && entry.copiedTo && store) {
           const data = await store.readBlob(entry.snapshotId ?? '', entry.copiedTo);
-          await ctx.fs.writeFile(abs, data);
+          await fsFacade.writeFile(abs, data);
         } else if (!entry.existed) {
           // 原文件不存在 → 删除导入写入的文件
-          if (await ctx.fs.exists(abs)) await ctx.fs.remove(abs);
+          if (await fsFacade.exists(abs)) await fsFacade.remove(abs);
         }
         return null;
       } catch (err) {

package/src/core/types.ts

@@ -525,6 +525,25 @@ export interface HostContext {
   workspace: WorkspaceFacade;
   patchFile: PatchFileFacade;
   fs: FileSystemFacade;
+  /**
+   * **系统 home 的绝对路径**（宿主解析；缺省 = 进程 `homedir()`）。
+   *
+   * 为什么需要：一部分第三方插件把数据放在 **$DSH_HOME 之外**（`~/.dsh-wallpaper-engine/`、
+   * `~/.mnemon/`、`~/.fastctx/` …），而 `fs` 被**限制在 $DSH_HOME 内**（越界即抛
+   * `host.fsPathEscape`）。`pluginData` / `pluginAssets` 两个分区的 ref 因此以**系统 home 为根**
+   * （见 `core/backup.ts` 的 `OS_HOME_FILE_SECTIONS`）。
+   *
+   * 判定纪律：**路径计算**用 `ctx.osHomeDir ?? homedir()`（`~` 的定义就是它，不是猜）；
+   * **真正的读写**必须经 `homeFs`，缺了它一律显式失败 —— 绝不退回 $DSH_HOME 写错位置。
+   */
+  osHomeDir?: string;
+  /**
+   * 以**系统 home 为根**的文件门面（与 `fs` 同一套方法、同样越界即抛；缺省 undefined）。
+   *
+   * 只允许 `pluginData` / `pluginAssets` 使用；其余分区一律走 `fs`（$DSH_HOME 内）。
+   * 缺省 = 宿主未提供（旧宿主）→ 这两个分区**不收集也不写入**，由 adapter 如实报码。
+   */
+  homeFs?: FileSystemFacade;
   /**
    * 会话存储端口（issue #45 会话归位；宿主注入对应 `ctx.sessionPersistence`）。
    *

package/src/foreign/registry.test.ts

@@ -207,7 +207,7 @@ test('契约：外来源单元 id → foreign:<source>:<section>:<unit>，且不
 test('契约：外来源前缀与 SectionId 无重叠（按构造互斥，不是靠约定）', () => {
   assert.equal(FOREIGN_UNIT_ID_PREFIX, 'foreign');
   assert.ok(!DSH_UNIT_ID_NAMESPACES.includes(FOREIGN_UNIT_ID_PREFIX));
-  // 15 个 SectionId 逐个都不能等于 foreign——用真实 DSH 形态反证
+  // 每个 SectionId 都不能等于 foreign——用真实 DSH 形态反证
   for (const { ns } of DSH_UNIT_IDS) {
     assert.notEqual(ns, FOREIGN_UNIT_ID_PREFIX, ns);
   }

package/src/foreign/registry.ts

@@ -336,7 +336,7 @@ export function isForeignUnitId(id: string): boolean {
 }
 
 /**
- * DSH 既有单元 id 的命名空间：分区 id（15 个 SectionId）或 plugin/patch/workspace；
+ * DSH 既有单元 id 的命名空间：分区 id（17 个 SectionId）或 plugin/patch/workspace；
  * 外来源形态（首段 = foreign）与无法识别的前缀一律 **null**。
  *
  * 两个方向都不误判是这条契约的核心（§8.3）：`foreign` 不在 SectionId 词表里、也不等于

package/src/index.ts

@@ -41,6 +41,7 @@ import { createWriteStream, existsSync, mkdirSync, readFileSync } from 'node:fs'
 import fs from 'node:fs/promises'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path'
+import { homedir } from 'node:os'
 import { promisify } from 'node:util'
 
 import type { Context } from '@deepseek-ai/cordis'
@@ -78,6 +79,7 @@ import { registerModelTools } from './core/model-tools.ts'
 import { msgOf, zhMsg } from './core/messages.ts'
 import { engineMsg, getEngineLocale, setEngineLanguageSource, setEngineLocale } from './core/engine-locale.ts'
 import { RollbackAutoTracker, RollbackPointEngine, rollbackSessionBindingOf, rollbackTrackedEventOf } from './core/rollback-point.ts'
+import { isRollbackEnabled, onRollbackEnabledChange, setRollbackEnabled } from './core/rollback-gate.ts'
 import type { RollbackForkCarrier, RollbackRewindResult } from './core/rollback-point.ts'
 // t3：宿主斜杠命令 /rollback（与 HTTP 路由同一道写入门；命令服务惰取，未组合时安静跳过）。
 import { agentSessionFactsOf, registerRollbackCommand } from './core/command-rollback.ts'
@@ -122,6 +124,7 @@ import { SyncSessionStore } from './sync/sync-session.ts'
 import { AutoSyncScheduler } from './sync/autosync-scheduler.ts'
 import { BackupScheduler } from './sync/backup-scheduler.ts'
 import { readBackupSchedule } from './sync/backup-schedule-config.ts'
+import { readRollbackEnabledSync } from './sync/ui-prefs.ts'
 import { AUTO_BACKUP_PREFIX, isValidExportFileName, resolveNonCollidingExportName, writeBackupNote } from './sync/backup-files.ts'
 import { DEFAULT_RETENTION_POLICY, selectPruneCandidatesByPolicy } from './sync/retention-policy.ts'
 import type { RetentionPolicy } from './sync/retention-policy.ts'
@@ -164,6 +167,8 @@ import { parseZip } from './utils/zip.ts'
 import { isSameOrChild } from './utils/paths.ts'
 import { isRecord } from './utils/guards.ts'
 import { createLogger, parseLogLevel, type Logger } from './utils/logger.ts'
+// 与 HTTP 路径**同一份**「运行中对话」判据（命令入口绝不能各写一套）
+import { sessionActiveDenied, sessionActiveGateApplies } from './routes/recovery.ts'
 
 /* ---------------------------------------------------------------- identity */
 
@@ -174,7 +179,7 @@ export const name = 'config-manager'
 export const inject = ['settings', 'credentials']
 
 /** Plugin version, kept in sync with package.json ("version"). */
-export const PLUGIN_VERSION = '0.1.72'
+export const PLUGIN_VERSION = '0.1.76'
 
 /** Plugin own package name — excluded from its own exported plugins list. */
 const PLUGIN_NAME = 'dsh-config-manager'
@@ -2006,6 +2011,10 @@ export class ConfigManagerHostContext implements HostContext {
   readonly workspace: WorkspaceFacade
   readonly patchFile: PatchFileFacade
   readonly fs: FileSystemFacade
+  /** 系统 home（第三方插件数据分区 pluginData / pluginAssets 的根；见 HostContext 的说明） */
+  readonly osHomeDir: string
+  /** 以系统 home 为根的文件门面（同样越界即抛；只有上面两个分区能用） */
+  readonly homeFs: FileSystemFacade
   /** 会话存储端口（issue #45 会话归位；对 ctx.sessionPersistence 的薄适配） */
   readonly sessions: SessionStoreFacade
   /**
@@ -2083,6 +2092,10 @@ export class ConfigManagerHostContext implements HostContext {
     this.plugins = new DshPluginsFacade(homeDir, profile, this.patchFile, undefined, this.msg)
     this.workspace = new DshWorkspaceFacade(ctx, this.msg)
     this.fs = new DshFileSystemFacade(homeDir, this.msg)
+    // 系统 home：一部分第三方插件把数据放在 $DSH_HOME 之外（~/.dsh-wallpaper-engine、~/.mnemon …），
+    // 那两个分区必须换根读写；门面本身与 $DSH_HOME 门面同一实现、同样被限制在它自己的根内。
+    this.osHomeDir = homedir()
+    this.homeFs = new DshFileSystemFacade(this.osHomeDir, this.msg)
     this.sessions = new DshSessionStoreFacade(ctx, homeDir, this.msg, this.log)
     // F-2：Cordis 的 fetch 服务（DSH 自己在用它转发 /api）。缺省回落进程全局 fetch（Node ≥18 恒有）。
     const fetchService = readService<unknown>(ctx, 'fetch')
@@ -4299,6 +4312,14 @@ export function apply(ctx: Context, config?: Config): void {
   const tmpDir = join(dataDir, 'tmp')
   const snapshotsDir = join(dataDir, 'snapshots')
   const syncDir = join(dataDir, 'sync')
+  /**
+   * issue #88 / #89：回合自动留点（回滚点）**缺省关闭**。
+   *
+   * 同步读一次偏好（几百字节），因为「关闭」必须在**注册 `session/event` 订阅之前**就定下来 ——
+   * 晚一步注册就等于「订阅了什么都做」（见 src/core/rollback-gate.ts 的三条设计）。
+   * 关闭后本进程不再留点、不再写台账；台账与回退路由本身仍可用（已有回滚点仍能查看 / 回退 / 清理）。
+   */
+  setRollbackEnabled(readRollbackEnabledSync(syncDir))
   const marketDir = join(dataDir, 'market')
   // Phase 6：迁移历史审计目录（统一历史引擎；加入 RESERVED_INTERNAL_PREFIXES 防 F23 投毒链）
   const historyDir = join(dataDir, MIGRATION_HISTORY_DIR)
@@ -4611,9 +4632,10 @@ export function apply(ctx: Context, config?: Config): void {
   }, 'config-manager: profile runtime heartbeat')
   // ------------------------------------------- S1：回合自动留点（宿主真接线）
   //
-  // 订阅 `session/event`（@deepseek-ai/dsh-session 的 post-commit fire-and-forget feed），
-  // 每见到一个 `turn/end` 就为**当前会话**留一个回滚点 = 工作区快照（内容寻址入对象仓）
-  // + 会话游标（事件数 / fork 边界）。没有手动「拍点」入口 —— 留点完全由回合驱动。
+  // 订阅 `session/event`（@deepseek-ai/dsh-session 的 post-commit fire-and-forget feed）。
+  // **留点在 `turn/start` 拍**（点的「工作区态」必须是该回合开始**之前**的样子 —— 这条口径不能动，
+  // 见 rollback-point.ts RollbackAutoTracker.noteEvent）；`turn/end` 只更新「缺省边界」，不再拍点。
+  // 没有手动「拍点」入口 —— 留点完全由回合驱动。
   //
   // 纪律（AGENTS.md 铁律 + captain 要求）：**订阅与每个回调都 try/catch 包裹**，任何异常
   // 只记 warn：改坏宿主启动 = blocker。事件回调用一条串行链喂给留点器，保证同一会话的
@@ -4632,7 +4654,9 @@ export function apply(ctx: Context, config?: Config): void {
         return { ok: false as const, code: 'session-fork-unavailable' as const, detail: 'facade has no forkSession' }
       }
       const result = await forkSession.call(forkPort, sessionId, boundarySeq)
-      if ('childSessionId' in result) {
+      // 形状加固：`in` 对 null / 原始值会抛 TypeError —— 端口漂移时应当是**结构化失败**，
+      // 而不是一个没人接的异常（宿主版本换形状时这条最先生效）。
+      if (result !== null && typeof result === 'object' && 'childSessionId' in result) {
         // warning 一路带到回退结果（引擎落成 rollback.guidance.sessionNotAttached）：
         // 归位失败**不静默** —— 会话确实回退了，但它会出现在侧栏「未分组」。
         return result.warning !== undefined
@@ -4648,10 +4672,24 @@ export function apply(ctx: Context, config?: Config): void {
     // 「会话没有 cwd」这类**形状合法但信息不全**的情况只记一次日志（避免每回合刷屏）；
     // 该点本身仍带 incomplete=true + workspace.reasonCode='no-chunks'，界面能如实展示。
     const chunklessLogged = new Set<string>()
+    /** 子代理会话只 warn 一次（见下面 'subagent-session' 分支） */
+    const inertSessionsLogged = new Set<string>()
     const listener = (session: unknown, event: unknown): void => {
+      // issue #88/#89 第一道门：关闭时回调什么都不做。正常路径下关闭时压根没有订阅
+      //（detach 已解绑），这里是「解绑与已派发事件之间」的竞态兜底。
+      if (!isRollbackEnabled()) return
       try {
         const bindingResult = rollbackSessionBindingOf(session)
         if (!bindingResult.ok) {
+          if (bindingResult.code === 'subagent-session') {
+            // 子代理会话按设计不留点：**每个会话只记一次**（否则每个事件刷一行 warn），
+            // 但仍然留痕 —— 不让「这个会话为什么没有点」变成无解释的沉默。
+            if (!inertSessionsLogged.has(bindingResult.detail)) {
+              inertSessionsLogged.add(bindingResult.detail)
+              host.log.warn('rollback auto point skipped: ' + bindingResult.code + ' ' + bindingResult.detail)
+            }
+            return
+          }
           // 形状不匹配**不静默**：给显式机器码，宿主日志留痕
           host.log.warn('rollback auto point skipped: ' + bindingResult.code + ' ' + bindingResult.detail)
           return
@@ -4676,13 +4714,32 @@ export function apply(ctx: Context, config?: Config): void {
       }
     }
     let off: (() => boolean) | null = null
-    try {
-      off = ctx.on('session/event', listener)
-    } catch (error) {
-      host.log.warn('rollback auto point subscribe failed: ' + (error instanceof Error ? error.message : String(error)))
+    /**
+     * 订阅 / 解绑成对：开关关闭时**真的解绑**（不是「订阅了什么都不做」—— issue #88 明确要求
+     * 「关闭后不再订阅 session/event」）。attach 幂等；订阅抛错只丢这一个入口，不打断宿主启动。
+     */
+    const attach = (): void => {
+      if (off !== null) return
+      try {
+        off = ctx.on('session/event', listener)
+      } catch (error) {
+        off = null
+        host.log.warn('rollback auto point subscribe failed: ' + (error instanceof Error ? error.message : String(error)))
+      }
+    }
+    const detach = (): void => {
+      const current = off
+      off = null
+      if (current === null) return
+      try { current() } catch { /* 解绑失败不影响卸载 */ }
     }
+    if (isRollbackEnabled()) attach()
+    // 活切换：写偏好的一方改开关，这里即时 attach / detach。事件回调**不读文件** ——
+    // 每回合读一次磁盘正是本 issue 要消灭的开销形态。
+    const unlisten = onRollbackEnabledChange((on) => { if (on) attach(); else detach() })
     return () => {
-      try { off?.() } catch { /* 解绑失败不影响卸载 */ }
+      unlisten()
+      detach()
       rollbackTracker.stop()
     }
   }, 'config-manager: rollback auto points')
@@ -4725,6 +4782,12 @@ export function apply(ctx: Context, config?: Config): void {
               warnings: preview.warnings,
             } satisfies RollbackRewindResult
           }
+          // ①b 与 HTTP 路径**同一道**「运行中对话」门：命令由会话循环派发、日志刚被 append，
+          //     `session.active` 通常为真；缺这道门就会出现「HTTP 会 409 拒绝的『运行中改工作区』
+          //     被命令入口放行」—— 写回的文件随即被运行中的步骤覆盖（撕裂态）。
+          if (preview.session.active === true && sessionActiveGateApplies(preview, true, host.safeModeIsBlocked?.() ?? false)) {
+            return sessionActiveDenied(id, preview)
+          }
           // ② 真执行：userConfirmed **恒 true** —— 用户敲下 /rollback <id> 就是那次确认
           //    （命令入口没有第二个确认按钮；其余门全量生效）。
           return await rollbackEngine.rewind({

package/src/routes/messages.ts

@@ -56,6 +56,7 @@ export const zh = {
   'route.recoverySessionLayoutPartial': '会话布局归位未全部完成（成功 {applied}，失败 {failed}，跳过 {skipped}）',
   'route.rollbackPointRewind': '回滚到回滚点：{outcome}',
   'route.rollbackPointDelete': '删除回滚点 {id}',
+  'route.rollbackPointCleanup': '清理回滚点台账：删除 {records} 个点',
   'route.recoveryOperationSummary': '恢复操作 {action}',
 } as const;
 
@@ -95,6 +96,7 @@ export const en: Record<keyof typeof zh, string> = {
   'route.recoverySessionLayoutPartial': 'Session layout relocation did not fully complete ({applied} succeeded, {failed} failed, {skipped} skipped)',
   'route.rollbackPointRewind': 'Rewind to rollback point: {outcome}',
   'route.rollbackPointDelete': 'Deleted rollback point {id}',
+  'route.rollbackPointCleanup': 'Cleaned up rollback-point ledger: {records} point(s) deleted',
   'route.recoveryOperationSummary': 'Recovery operation {action}',
 };
 

package/src/routes/prefs.ts

@@ -7,7 +7,9 @@
  * path/methods 就是唯一声明处；围栏、方法判定与顶层异常处理由 src/routes/kit.ts 在注册点统一提供。
  */
 
+import type { ServerResponse } from 'node:http'
 import { endpoint, requireJsonObject, writeJson } from './kit.ts'
+import { EnvironmentLockUnavailableError, runWithMutationLock } from '../utils/env-lock.ts'
 import type { WebRoute } from './kit.ts'
 import type { RoutesEnv } from './context.ts'
 import { PLUGIN_VERSION, STAR_PROMPT_REPO_URL } from '../index.ts'
@@ -16,10 +18,35 @@ import { UpdateChecker, wantsForcedUpdateCheck } from '../core/update-check.ts'
 
 export function prefsRoutes(env: RoutesEnv): WebRoute[] {
   const {
+    host,
     syncDir,
     selfUpdate,
     withMutationGate,
   } = env
+  /**
+   * 偏好写必须与其它写路径**同门**（④A）：ui-prefs.json 由 star-prompt / release-notes-prompt /
+   * 回滚开关三个端点共写。`updateUiPrefs` 虽是 read→merge→write，但两个端点**并发**时仍会互相覆盖
+   * 字段（典型：刚打开的 rollbackEnabled 被另一个端点的旧快照抹掉 ⇒ 重启后功能自己关掉，fail-closed）。
+   * 被 SAFE MODE / 环境锁挡住时直接回 423 并返回 null（调用方 return，零写入）。
+   */
+  const writePrefsOrBlocked = async (
+    res: ServerResponse,
+    patch: Parameters<typeof updateUiPrefs>[1],
+  ): Promise<Awaited<ReturnType<typeof updateUiPrefs>> | null> => {
+    try {
+      return await runWithMutationLock(
+        host.mutationLock,
+        { op: 'ui-prefs', target: 'star/release-notes', isBlocked: () => host.safeModeIsBlocked?.() ?? false },
+        async () => await updateUiPrefs(syncDir, patch),
+      )
+    } catch (error) {
+      if (error instanceof EnvironmentLockUnavailableError) {
+        writeJson(res, 423, { error: error.message, code: 'mutation-locked' })
+        return null
+      }
+      throw error
+    }
+  }
   // 版本更新检查器：每进程一个（进程内缓存 10 分钟；用户点「重新检查」走 ?force=1）。
   // 网络失败/超时/响应畸形一律结构化回传（ok:false + 原因），绝不「失败当最新」。
   const updateChecker = new UpdateChecker(PLUGIN_VERSION)
@@ -58,7 +85,8 @@ export function prefsRoutes(env: RoutesEnv): WebRoute[] {
         if (body['clicked'] === true) {
           patch['starPromptClicked'] = true
         }
-        const next = await updateUiPrefs(syncDir, patch)
+        const next = await writePrefsOrBlocked(res, patch)
+        if (next === null) return
         writeJson(res, 200, {
           ok: true,
           firstSeenAt: next.starPromptFirstSeenAt,
@@ -98,7 +126,8 @@ export function prefsRoutes(env: RoutesEnv): WebRoute[] {
         if (body['dismissed'] === true) {
           patch['releaseNotesDismissed'] = true
         }
-        const next = await updateUiPrefs(syncDir, patch)
+        const next = await writePrefsOrBlocked(res, patch)
+        if (next === null) return
         writeJson(res, 200, {
           ok: true,
           lastSeenVersion: next.releaseNotesLastSeenVersion,

package/src/routes/recovery.ts

@@ -12,7 +12,9 @@ import { engineMsg } from './messages.ts'
 import type { WebRoute } from './kit.ts'
 import type { RoutesEnv } from './context.ts'
 import { isValidOperationId } from '../core/journal.ts'
-import { RollbackPointEngine } from '../core/rollback-point.ts'
+import { RollbackLedgerRefusedError, RollbackPointEngine } from '../core/rollback-point.ts'
+import { isRollbackEnabled, setRollbackEnabled } from '../core/rollback-gate.ts'
+import { readRollbackEnabledSync, updateUiPrefs } from '../sync/ui-prefs.ts'
 import type { RollbackForkSeam, RollbackPreviewResult, RollbackRewindInput, RollbackRewindResult } from '../core/rollback-point.ts'
 import { reconcileForkSessions, type ForkReconcileChild, type ForkReconcileOutcome } from '../core/fork-reconcile.ts'
 import { EnvironmentLockUnavailableError, runWithMutationLock } from '../utils/env-lock.ts'
@@ -102,7 +104,7 @@ function rewindTouchesWorkspace(input: { mode?: string; segments?: readonly stri
  *
  * 两道门（R1 预检 / R2 锁内二道保险）共用这一份判据，绝不各写一套。
  */
-function sessionActiveGateApplies(
+export function sessionActiveGateApplies(
   preview: RollbackPreviewResult,
   userConfirmed: boolean,
   safeModeBlocked: boolean,
@@ -119,7 +121,7 @@ function sessionActiveGateApplies(
  * 判据来源只有一个：**preview 已算出的 `session.active`**（引擎按会话日志 mtime 静默窗算）——
  * 路由**绝不自己 stat 会话日志**（那会变成第二份判据，两处迟早漂移）。
  */
-function sessionActiveDenied(id: string, preview: RollbackPreviewResult): RollbackRewindResult {
+export function sessionActiveDenied(id: string, preview: RollbackPreviewResult): RollbackRewindResult {
   return {
     ok: false,
     outcome: 'denied',
@@ -219,12 +221,19 @@ function forkSeamOf(sessions: unknown): RollbackForkSeam | undefined {
   if (sessions === null || typeof sessions !== 'object') return undefined
   const candidate = (sessions as { forkSession?: unknown }).forkSession
   if (typeof candidate !== 'function') return undefined
-  const fork = candidate as (sessionId: string, boundarySeq: number) => Promise<{ childSessionId: string } | { error: string }>
+  const fork = candidate as (sessionId: string, boundarySeq: number) => Promise<{ childSessionId: string; warning?: string } | { error: string }>
   return async ({ sessionId, boundarySeq }) => {
     try {
       const result = await fork.call(sessions, sessionId, boundarySeq)
       const childId = result !== null && typeof result === 'object' ? (result as { childSessionId?: unknown }).childSessionId : undefined
-      if (typeof childId === 'string' && childId !== '') return { ok: true, childSessionId: childId }
+      if (typeof childId === 'string' && childId !== '') {
+        // 归位失败（宿主三档都没命中）必须一路带到结果里：丢掉它就会出现「HTTP 入口说已归位、
+        // /rollback 命令说没归位」的矛盾（子会话实际停在侧栏「未分组」）。
+        const warning = (result as { warning?: unknown }).warning
+        return typeof warning === 'string' && warning !== ''
+          ? { ok: true, childSessionId: childId, warning }
+          : { ok: true, childSessionId: childId }
+      }
       const error = result !== null && typeof result === 'object' ? (result as { error?: unknown }).error : undefined
       return { ok: false, code: 'fork-failed', detail: typeof error === 'string' ? error : 'fork-returned-no-id' }
     } catch (err) {
@@ -528,6 +537,9 @@ export function recoveryRoutes(env: RoutesEnv): WebRoute[] {
           log: (line) => host.log.warn(line),
           ...(forkSeam !== undefined ? { fork: forkSeam } : {}),
         })
+        // 插件偏好文件与 /sync/ui-prefs 同一份（dataDir/sync/ui-prefs.json）；回滚点开关存在那里，
+        // 所以这里派生同一个目录，绝不另立第二个偏好文件。
+        const syncDir = join(dataDir, 'sync')
         const sub = segments.slice(1)
         const methodNotAllowed = (): void => { writeJson(res, 405, { error: 'method not allowed', code: 'method-not-allowed' }) }
         const reply = (value: { ok?: boolean; code?: string; outcome?: string }): void => {
@@ -553,14 +565,117 @@ export function recoveryRoutes(env: RoutesEnv): WebRoute[] {
            *    仍读不到就不加该字段（界面回落显示会话 id），**绝不从首条消息编造标题**。
            */
           const titled = await applySessionLogTitles(points, join(sessionHealth.homeDir, 'sessions'))
-          writeJson(res, listed.storage.available ? 200 : 503, { ...listed, points: titled })
+          // 列表响应里的 storage 也带上开关与台账占用：界面**只读这一个响应**就能画开关、
+          // 画占用、并决定聊天入口是否收起（少一次请求，也少一处口径分叉）。
+          const storageWithPrefs = {
+            ...listed.storage,
+            rollbackEnabled: readRollbackEnabledSync(syncDir),
+            rollbackActive: isRollbackEnabled(),
+          }
+          writeJson(res, listed.storage.available ? 200 : 503, { ...listed, storage: storageWithPrefs, points: titled })
           return
         }
         // 存储栈状态（缺失时给结构化组合指引；**不崩**）
+        // issue #89 P2：随状态一并回传**台账占用**（记录数 / 字节 / 预算 / 已淘汰数，见 engine.storageStatus 的 ledger）
+        // 与开关（rollbackEnabled = 磁盘偏好；rollbackActive = 本进程当前是否真的在留点）。
         if (sub.length === 1 && sub[0] === 'storage') {
           if (req.method !== 'GET') { methodNotAllowed(); return }
           const status = await engine.storageStatus()
-          writeJson(res, status.available ? 200 : 503, { ok: status.available, ...status })
+          writeJson(res, status.available ? 200 : 503, {
+            ok: status.available,
+            rollbackEnabled: readRollbackEnabledSync(syncDir),
+            rollbackActive: isRollbackEnabled(),
+            ...status,
+          })
+          return
+        }
+        // 回合自动留点的总开关（issue #88 / #89）。
+        //
+        // 为什么要读写两个语义：磁盘偏好（rollbackEnabled）是**用户意图**、随 self 分区进备份；
+        // 进程 gate（rollbackActive）是**此刻真正生效**的东西（关闭后订阅已解绑）。两者正常一致，
+        // 只在「另一进程改了文件」这类边界上短暂分叉 —— 分歧就如实分开报，不合并成一个布尔。
+        //
+        // 写路径过 mutation gate：它改的是「宿主会不会每回合写盘」的行为语义，与 rewind / delete 同级
+        //（都在同一把锁里，拒绝一律发生在写任何字节之前）。
+        if (sub.length === 1 && sub[0] === 'prefs') {
+          if (req.method === 'GET') {
+            writeJson(res, 200, { ok: true, rollbackEnabled: readRollbackEnabledSync(syncDir), rollbackActive: isRollbackEnabled() })
+            return
+          }
+          if (req.method !== 'POST') { methodNotAllowed(); return }
+          try {
+            const body = await readJsonBody(req)
+            if (body === undefined) { writeJson(res, 400, { ok: false, code: 'invalid-input', error: 'invalid JSON body' }); return }
+            const wanted = body['rollbackEnabled']
+            if (typeof wanted !== 'boolean') {
+              writeJson(res, 400, { ok: false, code: 'invalid-input', error: 'rollbackEnabled must be a boolean' })
+              return
+            }
+            await runWithMutationLock(
+              host.mutationLock,
+              { op: 'rollback-prefs', target: 'rollbackEnabled', isBlocked: () => host.safeModeIsBlocked?.() ?? false },
+              async () => {
+                await updateUiPrefs(syncDir, { rollbackEnabled: wanted })
+                // 写盘成功才切进程 gate：写失败却把功能打开，等于「界面说开着、实际不留点」
+                setRollbackEnabled(wanted)
+              },
+            )
+            writeJson(res, 200, { ok: true, rollbackEnabled: wanted, rollbackActive: isRollbackEnabled() })
+          } catch (error) {
+            if (error instanceof EnvironmentLockUnavailableError) {
+              host.log.warn('mutation lock blocked: op=rollback-prefs reason=' + error.reason)
+              writeJson(res, 423, { error: error.message, code: 'mutation-locked' })
+              return
+            }
+            writeJson(res, 500, { error: error instanceof Error ? error.message : String(error) })
+          }
+          return
+        }
+        // 台账清理（issue #89 P1/P2）：把「已经涨上去的占用」收回来。
+        //
+        // 为什么单独一条子路径而不是并进「磁盘占用清理」：那条清理的候选集被四条不变量钉死
+        // （只有可重建区 + 显式勾选的过期导出；snapshots/sync 永不进候选）。回滚点是**数据**不是
+        // 可重建区，用户没显式勾选就不能被任何「一键清理」顺走 —— 所以它是自己这条显式入口，
+        // 且默认只删自动点（救援点要显式勾选）。语义与单条 delete 一致，只是作用域是整个台账。
+        if (sub.length === 1 && sub[0] === 'cleanup') {
+          if (req.method !== 'POST') { methodNotAllowed(); return }
+          try {
+            const body = await readJsonBody(req)
+            if (body === undefined) { writeJson(res, 400, { ok: false, code: 'invalid-input', error: 'invalid JSON body' }); return }
+            // 与单条 delete 同一条 fail-closed 确认门：必须**恰好** true，缺省不放行
+            if (body['userConfirmed'] !== true) {
+              writeJson(res, 409, { ok: false, code: 'confirmation-required' })
+              return
+            }
+            const includeGuards = body['includeGuards'] === true
+            const result = await runWithMutationLock(
+              host.mutationLock,
+              { op: 'rollback-cleanup', target: includeGuards ? 'auto+guard' : 'auto', isBlocked: () => host.safeModeIsBlocked?.() ?? false },
+              async () => await engine.purgeLedger({ includeGuards }),
+            )
+            await tryAppendHistory({
+              kind: 'recovery',
+              result: 'success',
+              sections: [],
+              source: 'recovery',
+              summary: engineMsg('route.rollbackPointCleanup', { records: String(result.removedRecords) }),
+            })
+            writeJson(res, 200, { ok: true, ...result })
+          } catch (error) {
+            if (error instanceof EnvironmentLockUnavailableError) {
+              host.log.warn('mutation lock blocked: op=rollback-cleanup reason=' + error.reason)
+              writeJson(res, 423, { error: error.message, code: 'mutation-locked' })
+              return
+            }
+            // 引擎侧的**显式拒绝**带机器码（存储不可用 / 台账读不出）：按码映射 HTTP，
+            // 不回落成泛化 500 —— 界面要能说清「是存储栈缺了」还是「台账真读不出来」。
+            if (error instanceof RollbackLedgerRefusedError) {
+              host.log.warn('rollback cleanup refused: ' + error.code + ' ' + error.message)
+              writeJson(res, error.code === 'storage-unavailable' ? 503 : 500, { ok: false, code: error.code, detail: error.message })
+              return
+            }
+            writeJson(res, 500, { error: error instanceof Error ? error.message : String(error) })
+          }
           return
         }
         // 单条详情（只读：两态摘要 + 完整记录）

package/src/routes/sync.ts

@@ -6,6 +6,7 @@
  */
 
 import { endpoint, requireJsonObject, readJsonBody, writeJson } from './kit.ts'
+import { EnvironmentLockUnavailableError, runWithMutationLock } from '../utils/env-lock.ts'
 import type { WebRoute } from './kit.ts'
 import type { RoutesEnv } from './context.ts'
 import { FileSnapshotStore } from '../core/index.ts'
@@ -320,9 +321,22 @@ export function syncRoutes(env: RoutesEnv): WebRoute[] {
       const body = await requireJsonObject(req)
       try {
         const channel: UiPrefsChannel | undefined = parseSyncChannel(body['lastSyncChannel'])
-        await updateUiPrefs(syncDir, { ...(channel !== undefined ? { lastSyncChannel: channel } : {}) })
+        // ④A：与回滚开关端点**同一道写入门**。ui-prefs.json 由三个端点共写，`updateUiPrefs` 虽是
+        // read→merge→write，但两个不同端点并发时仍会互相覆盖字段（例如把刚打开的 rollbackEnabled 抹掉，
+        // 重启后功能自己关掉）。同类写串行是既有架构口径。
+        await runWithMutationLock(
+          host.mutationLock,
+          { op: 'ui-prefs', target: 'lastSyncChannel', isBlocked: () => host.safeModeIsBlocked?.() ?? false },
+          async () => {
+            await updateUiPrefs(syncDir, { ...(channel !== undefined ? { lastSyncChannel: channel } : {}) })
+          },
+        )
         writeJson(res, 200, { ok: true, lastSyncChannel: channel })
       } catch (error) {
+        if (error instanceof EnvironmentLockUnavailableError) {
+          writeJson(res, 423, { error: error.message, code: 'mutation-locked' })
+          return
+        }
         writeSyncRouteError(res, error)
       }
     }),

package/src/schema/manifest-schema.test.ts

@@ -281,7 +281,7 @@ test('K-04 x-* 扩展键仅作为根级文档说明存在，且分区 id 表与
   assert.ok(xKeys.includes('x-semantic-constraints'), '应显式记录 JSON Schema 无法表达的语义约束');
   assert.deepEqual(
     SCHEMA['x-section-ids'], [...SECTION_IDS],
-    'schema 记录的 15 个分区 id 必须与 SECTION_IDS 完全一致（防止分区增删后文档漂移）',
+    'schema 记录的分区 id 必须与 SECTION_IDS 完全一致（防止分区增删后文档漂移）',
   );
   assert.equal(SCHEMA['x-format-version'], 'Bundle Format v1');
   assert.equal(SCHEMA['x-schema-version-constant'], CURRENT_SCHEMA_VERSION);
@@ -322,10 +322,10 @@ test('S-01 真实 buildManifest 产物满足 schema 声明的全部必需字段
   assert.deepEqual(errorPaths(m), [], '且必须零 validateManifest error');
 });
 
-test('S-02 sections 恒含全部 15 个已知分区 id（规格 §2.5），值均为布尔', () => {
+test('S-02 sections 恒含全部已知分区 id（规格 §2.5），值均为布尔', () => {
   const m = baselineManifest();
   const keys = Object.keys(m.sections).sort();
-  assert.equal(SECTION_IDS.length, 15, 'SectionId 共 15 个（含无 adapter 的 secrets）');
+  assert.equal(SECTION_IDS.length, 17, 'SectionId 共 17 个（含无 adapter 的 secrets）');
   assert.deepEqual(keys, [...SECTION_IDS].sort(), 'sections 键集合必须等于 SECTION_IDS');
   for (const key of keys) {
     assert.equal(typeof m.sections[key as (typeof SECTION_IDS)[number]], 'boolean', `sections.${key} 必须是布尔`);
@@ -333,7 +333,7 @@ test('S-02 sections 恒含全部 15 个已知分区 id（规格 §2.5），值
   assert.deepEqual(validateAgainstSchema(SCHEMA, m), [], '全量 sections 必须满足 schema');
 });
 
-test('S-03 全部 15 个分区置 true 的 manifest 仍满足 schema（sections 是开放布尔映射）', () => {
+test('S-03 全部分区置 true 的 manifest 仍满足 schema（sections 是开放布尔映射）', () => {
   const all = sectionsAllFalse();
   for (const id of SECTION_IDS) all[id] = true;
   const m = buildManifest({

package/src/schema/registry.test.ts

@@ -47,6 +47,9 @@ const HISTORICAL_SECTION_IDS: readonly SectionId[] = [
   'settings', 'ui', 'providers', 'plugins', 'mcp', 'prompts',
   'skills', 'agentPresets', 'agentInstructions', 'workspaces', 'pluginFiles',
   'credentialsStatus', 'secrets', 'sessions', 'self',
+  // 2026-10-14 追加：第三方插件数据（pluginData 配置类 / pluginAssets 大资产类）——
+  // 历史字面量到此为止的部分逐字未改，新分区只允许**追加**在末尾。
+  'pluginData', 'pluginAssets',
 ];
 const HISTORICAL_JSON_PATHS: ReadonlyArray<readonly [SectionId, string]> = [
   ['settings', 'config/settings.json'],
@@ -65,16 +68,18 @@ const HISTORICAL_FILE_PREFIXES: ReadonlyArray<readonly [SectionId, string]> = [
   ['pluginFiles', 'plugin-files/'],
   ['sessions', 'sessions/'],
   ['self', 'self/'],
+  ['pluginData', 'plugin-data/'],
+  ['pluginAssets', 'plugin-assets/'],
 ];
 
 /* ---------------- 行为等价（顺序 + 内容） ---------------- */
 
 test('registry: SECTION_IDS 与历史数组逐项一致（顺序 = applyOrder 升序）', () => {
   assert.deepEqual([...SECTION_IDS], [...HISTORICAL_SECTION_IDS]);
-  assert.equal(SECTION_IDS.length, 15);
+  assert.equal(SECTION_IDS.length, 17);
   const orders = SECTION_IDS.map((id) => SECTION_REGISTRY[id].applyOrder);
   assert.deepEqual(orders, [...orders].sort((a, b) => a - b), 'applyOrder 必须与 SECTION_IDS 顺序一致');
-  assert.deepEqual(orders, Array.from({ length: 15 }, (_, i) => i + 1), 'applyOrder 连续且从 1 起');
+  assert.deepEqual(orders, Array.from({ length: 17 }, (_, i) => i + 1), 'applyOrder 连续且从 1 起');
 });
 
 test('registry: SECTION_JSON_PATHS / SECTION_FILE_PREFIXES 与历史字面量逐项一致（含键顺序）', () => {
@@ -219,6 +224,8 @@ const HISTORICAL_RISK_TIERS: Readonly<Record<string, SectionRiskTier>> = {
   skills: 'low', agentPresets: 'low', agentInstructions: 'low',
   pluginFiles: 'high', sessions: 'high', self: 'low',
   credentialsStatus: 'high', secrets: 'high',
+  // 第三方插件数据：内容是任意文件（可能含凭据），且换机后位置可能不存在 → high
+  pluginData: 'high', pluginAssets: 'high',
 };
 
 test('registry: 每个分区都声明 riskTier，且与改造前的分级逐项一致（行为等价）', () => {