dsh-config-manager 0.1.72 → 0.1.76

package/lib/core/rollback.js

@@ -7,7 +7,7 @@
  *    如实标记 failed + manualHint（人工补录）；
  *  - settings 回滚仍走 expectedRevision 乐观锁，避免覆盖导入后用户的新修改。
  */
-import { resolveFileTarget } from './backup.js';
+import { fsForSection, resolveFileTarget } from './backup.js';
 import { isPatchLayerRel, USER_PATCH_FILE } from './patch-layers.js';
 import { msgOf } from './messages.js';
 /** 逆序补偿单条快照条目；返回 null=成功，否则为失败原因 */
@@ -75,15 +75,17 @@ async function compensateOne(entry, ctx, store) {
         }
         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;
             }

package/lib/core/types.d.ts

@@ -533,6 +533,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/lib/foreign/registry.d.ts

@@ -155,7 +155,7 @@ export interface ForeignUnitIdParts {
 export declare function parseForeignUnitId(id: string): ForeignUnitIdParts | null;
 export declare 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/lib/foreign/registry.js

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

package/lib/index.d.ts

@@ -78,7 +78,7 @@ export declare const name = "config-manager";
 /** Services required before the engine can mount (present in every profile). */
 export declare const inject: string[];
 /** Plugin version, kept in sync with package.json ("version"). */
-export declare const PLUGIN_VERSION = "0.1.72";
+export declare const PLUGIN_VERSION = "0.1.76";
 /**
  * Star 引导弹窗指向的 GitHub 仓库（用户引导点 Star 的目标）。
  * 与 package.json 的 repository 字段保持一致；界面不可改（硬编码，参照
@@ -687,6 +687,10 @@ export declare 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;
     /**

package/lib/index.js

@@ -39,6 +39,7 @@ import { execFile } from 'node:child_process';
 import { createWriteStream, existsSync, mkdirSync, readFileSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { homedir } from 'node:os';
 import { promisify } from 'node:util';
 import * as dshSettings from '@deepseek-ai/dsh-settings';
 import * as dshCredentials from '@deepseek-ai/dsh-credentials';
@@ -64,6 +65,7 @@ import { registerModelTools } from './core/model-tools.js';
 import { msgOf, zhMsg } from './core/messages.js';
 import { engineMsg, getEngineLocale, setEngineLanguageSource, setEngineLocale } from './core/engine-locale.js';
 import { RollbackAutoTracker, RollbackPointEngine, rollbackSessionBindingOf, rollbackTrackedEventOf } from './core/rollback-point.js';
+import { isRollbackEnabled, onRollbackEnabledChange, setRollbackEnabled } from './core/rollback-gate.js';
 // t3：宿主斜杠命令 /rollback（与 HTTP 路由同一道写入门；命令服务惰取，未组合时安静跳过）。
 import { agentSessionFactsOf, registerRollbackCommand } from './core/command-rollback.js';
 import { cleanupAbortedInstall, hasDshBundlePatch, installAnchorFromProfileContext, installErrorFor, installSpecFor, listInstalledPlugins, profileNameFromProfileContext, resolveProcessProfileName, resolveProfileDir, readProfileManifest, runDshPlugin, validateProfileName } from './core/plugin-cli.js';
@@ -98,6 +100,7 @@ import { SyncSessionStore } from './sync/sync-session.js';
 import { AutoSyncScheduler } from './sync/autosync-scheduler.js';
 import { BackupScheduler } from './sync/backup-scheduler.js';
 import { readBackupSchedule } from './sync/backup-schedule-config.js';
+import { readRollbackEnabledSync } from './sync/ui-prefs.js';
 import { AUTO_BACKUP_PREFIX, isValidExportFileName, resolveNonCollidingExportName, writeBackupNote } from './sync/backup-files.js';
 import { DEFAULT_RETENTION_POLICY, selectPruneCandidatesByPolicy } from './sync/retention-policy.js';
 import { selectPruneCandidates } from './core/backup.js';
@@ -125,13 +128,15 @@ import { parseZip } from './utils/zip.js';
 import { isSameOrChild } from './utils/paths.js';
 import { isRecord } from './utils/guards.js';
 import { createLogger, parseLogLevel } from './utils/logger.js';
+// 与 HTTP 路径**同一份**「运行中对话」判据（命令入口绝不能各写一套）
+import { sessionActiveDenied, sessionActiveGateApplies } from './routes/recovery.js';
 /* ---------------------------------------------------------------- identity */
 /** Stable cordis plugin name — must match the cordis.patch.yml row id. */
 export const name = 'config-manager';
 /** Services required before the engine can mount (present in every profile). */
 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';
 /**
@@ -1779,6 +1784,10 @@ export class ConfigManagerHostContext {
     workspace;
     patchFile;
     fs;
+    /** 系统 home（第三方插件数据分区 pluginData / pluginAssets 的根；见 HostContext 的说明） */
+    osHomeDir;
+    /** 以系统 home 为根的文件门面（同样越界即抛；只有上面两个分区能用） */
+    homeFs;
     /** 会话存储端口（issue #45 会话归位；对 ctx.sessionPersistence 的薄适配） */
     sessions;
     /**
@@ -1854,6 +1863,10 @@ export class ConfigManagerHostContext {
         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(ctx, 'fetch');
@@ -3928,6 +3941,14 @@ export function apply(ctx, config) {
     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);
@@ -4252,9 +4273,10 @@ export function apply(ctx, config) {
     }, '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。事件回调用一条串行链喂给留点器，保证同一会话的
@@ -4273,7 +4295,9 @@ export function apply(ctx, config) {
                 return { ok: false, code: 'session-fork-unavailable', 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
@@ -4289,10 +4313,25 @@ export function apply(ctx, config) {
         // 「会话没有 cwd」这类**形状合法但信息不全**的情况只记一次日志（避免每回合刷屏）；
         // 该点本身仍带 incomplete=true + workspace.reasonCode='no-chunks'，界面能如实展示。
         const chunklessLogged = new Set();
+        /** 子代理会话只 warn 一次（见下面 'subagent-session' 分支） */
+        const inertSessionsLogged = new Set();
         const listener = (session, event) => {
+            // 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;
@@ -4318,17 +4357,42 @@ export function apply(ctx, config) {
             }
         };
         let off = 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)));
-        }
-        return () => {
+        /**
+         * 订阅 / 解绑成对：开关关闭时**真的解绑**（不是「订阅了什么都不做」—— issue #88 明确要求
+         * 「关闭后不再订阅 session/event」）。attach 幂等；订阅抛错只丢这一个入口，不打断宿主启动。
+         */
+        const attach = () => {
+            if (off !== null)
+                return;
             try {
-                off?.();
+                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 = () => {
+            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 () => {
+            unlisten();
+            detach();
             rollbackTracker.stop();
         };
     }, 'config-manager: rollback auto points');
@@ -4368,6 +4432,12 @@ export function apply(ctx, config) {
                         warnings: preview.warnings,
                     };
                 }
+                // ①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/lib/routes/messages.d.ts

@@ -35,6 +35,7 @@ export declare const zh: {
     readonly 'route.recoverySessionLayoutPartial': '会话布局归位未全部完成（成功 {applied}，失败 {failed}，跳过 {skipped}）';
     readonly 'route.rollbackPointRewind': '回滚到回滚点：{outcome}';
     readonly 'route.rollbackPointDelete': '删除回滚点 {id}';
+    readonly 'route.rollbackPointCleanup': '清理回滚点台账：删除 {records} 个点';
     readonly 'route.recoveryOperationSummary': '恢复操作 {action}';
 };
 export declare const en: Record<keyof typeof zh, string>;

package/lib/routes/messages.js

@@ -54,6 +54,7 @@ export const zh = {
     'route.recoverySessionLayoutPartial': '会话布局归位未全部完成（成功 {applied}，失败 {failed}，跳过 {skipped}）',
     'route.rollbackPointRewind': '回滚到回滚点：{outcome}',
     'route.rollbackPointDelete': '删除回滚点 {id}',
+    'route.rollbackPointCleanup': '清理回滚点台账：删除 {records} 个点',
     'route.recoveryOperationSummary': '恢复操作 {action}',
 };
 export const en = {
@@ -92,6 +93,7 @@ export const en = {
     '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}',
 };
 registerMessageCatalog({ id: 'routes-domain', zh, en });

package/lib/routes/prefs.js

@@ -7,11 +7,30 @@
  * path/methods 就是唯一声明处；围栏、方法判定与顶层异常处理由 src/routes/kit.ts 在注册点统一提供。
  */
 import { endpoint, requireJsonObject, writeJson } from './kit.js';
+import { EnvironmentLockUnavailableError, runWithMutationLock } from '../utils/env-lock.js';
 import { PLUGIN_VERSION, STAR_PROMPT_REPO_URL } from '../index.js';
 import { readUiPrefs, updateUiPrefs } from '../sync/ui-prefs.js';
 import { UpdateChecker, wantsForcedUpdateCheck } from '../core/update-check.js';
 export function prefsRoutes(env) {
-    const { syncDir, selfUpdate, withMutationGate, } = env;
+    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, patch) => {
+        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);
@@ -51,7 +70,9 @@ export function prefsRoutes(env) {
                 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,
@@ -93,7 +114,9 @@ export function prefsRoutes(env) {
                 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/lib/routes/recovery.d.ts

@@ -6,4 +6,25 @@
  */
 import type { WebRoute } from './kit.ts';
 import type { RoutesEnv } from './context.ts';
+import type { RollbackPreviewResult, RollbackRewindResult } from '../core/rollback-point.ts';
+/**
+ * t8 的硬拒**什么时候该生效**（判定链里的位置，t8 实现说明的选项 ②）。
+ *
+ * 既有护栏**优先**：确认门没开（`userConfirmed !== true`）、该点本来就不可回退
+ * （`preview.ok !== true || preview.canRestore !== true`：protected / record-incomplete /
+ * 记录不存在 / 存储不可用）、或 SAFE MODE 正拦着（由锁门给 423）时，**把结论让给引擎自己的
+ * 结构化拒绝** —— 那些情形下说「对话正在运行」是误导：用户等多久都退不了。
+ * 只有「这次本来能退、只是因为它正在运行而不能动工作区」时，才用 `session-active`。
+ *
+ * 两道门（R1 预检 / R2 锁内二道保险）共用这一份判据，绝不各写一套。
+ */
+export declare function sessionActiveGateApplies(preview: RollbackPreviewResult, userConfirmed: boolean, safeModeBlocked: boolean): boolean;
+/**
+ * 运行中对话的拒绝结果（t8）：**形状与引擎的 rewind 结果同构**，两处（路由预检 / 锁内二道保险）
+ * 共用一份，界面照常走「结果 → 文案」那条链。`segments` 恒为空 = 一段都没动（零写入）。
+ *
+ * 判据来源只有一个：**preview 已算出的 `session.active`**（引擎按会话日志 mtime 静默窗算）——
+ * 路由**绝不自己 stat 会话日志**（那会变成第二份判据，两处迟早漂移）。
+ */
+export declare function sessionActiveDenied(id: string, preview: RollbackPreviewResult): RollbackRewindResult;
 export declare function recoveryRoutes(env: RoutesEnv): WebRoute[];

package/lib/routes/recovery.js

@@ -9,7 +9,9 @@ import { endpoint, readJsonBody, writeJson } from './kit.js';
 // `msg` 同源（t2 起 this.msg = engineMsg），但它是**活翻译器**，不依赖 env 是否注入取词器。
 import { engineMsg } from './messages.js';
 import { isValidOperationId } from '../core/journal.js';
-import { RollbackPointEngine } from '../core/rollback-point.js';
+import { RollbackLedgerRefusedError, RollbackPointEngine } from '../core/rollback-point.js';
+import { isRollbackEnabled, setRollbackEnabled } from '../core/rollback-gate.js';
+import { readRollbackEnabledSync, updateUiPrefs } from '../sync/ui-prefs.js';
 import { reconcileForkSessions } from '../core/fork-reconcile.js';
 import { EnvironmentLockUnavailableError, runWithMutationLock } from '../utils/env-lock.js';
 import { scanSessionHealth } from '../utils/session-health-scan.js';
@@ -100,7 +102,7 @@ function rewindTouchesWorkspace(input) {
  *
  * 两道门（R1 预检 / R2 锁内二道保险）共用这一份判据，绝不各写一套。
  */
-function sessionActiveGateApplies(preview, userConfirmed, safeModeBlocked) {
+export function sessionActiveGateApplies(preview, userConfirmed, safeModeBlocked) {
     if (safeModeBlocked)
         return false;
     if (!userConfirmed)
@@ -114,7 +116,7 @@ function sessionActiveGateApplies(preview, userConfirmed, safeModeBlocked) {
  * 判据来源只有一个：**preview 已算出的 `session.active`**（引擎按会话日志 mtime 静默窗算）——
  * 路由**绝不自己 stat 会话日志**（那会变成第二份判据，两处迟早漂移）。
  */
-function sessionActiveDenied(id, preview) {
+export function sessionActiveDenied(id, preview) {
     return {
         ok: false,
         outcome: 'denied',
@@ -221,8 +223,14 @@ function forkSeamOf(sessions) {
         try {
             const result = await fork.call(sessions, sessionId, boundarySeq);
             const childId = result !== null && typeof result === 'object' ? result.childSessionId : undefined;
-            if (typeof childId === 'string' && childId !== '')
-                return { ok: true, childSessionId: childId };
+            if (typeof childId === 'string' && childId !== '') {
+                // 归位失败（宿主三档都没命中）必须一路带到结果里：丢掉它就会出现「HTTP 入口说已归位、
+                // /rollback 命令说没归位」的矛盾（子会话实际停在侧栏「未分组」）。
+                const warning = result.warning;
+                return typeof warning === 'string' && warning !== ''
+                    ? { ok: true, childSessionId: childId, warning }
+                    : { ok: true, childSessionId: childId };
+            }
             const error = result !== null && typeof result === 'object' ? result.error : undefined;
             return { ok: false, code: 'fork-failed', detail: typeof error === 'string' ? error : 'fork-returned-no-id' };
         }
@@ -534,6 +542,9 @@ export function recoveryRoutes(env) {
                     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 = () => { writeJson(res, 405, { error: 'method not allowed', code: 'method-not-allowed' }); };
                 const reply = (value) => {
@@ -559,17 +570,126 @@ export function recoveryRoutes(env) {
                      *    仍读不到就不加该字段（界面回落显示会话 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/lib/routes/sync.js

@@ -5,6 +5,7 @@
  * path/methods 就是唯一声明处；围栏、方法判定与顶层异常处理由 src/routes/kit.ts 在注册点统一提供。
  */
 import { endpoint, requireJsonObject, readJsonBody, writeJson } from './kit.js';
+import { EnvironmentLockUnavailableError, runWithMutationLock } from '../utils/env-lock.js';
 import { FileSnapshotStore } from '../core/index.js';
 import { rollback as performRollback } from '../core/rollback.js';
 /**
@@ -273,10 +274,19 @@ export function syncRoutes(env) {
             const body = await requireJsonObject(req);
             try {
                 const channel = 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/lib/schema/section-registry.d.ts

@@ -172,7 +172,7 @@ export interface SectionMeta {
      */
     readonly configSnapshot: boolean;
 }
-/** 分区载荷版本：当前 15 个分区统一为 1（唯一字面量；分区可独立升级时只改对应条目的引用） */
+/** 分区载荷版本：当前 17 个分区统一为 1（唯一字面量；分区可独立升级时只改对应条目的引用） */
 export declare const SECTION_DATA_VERSION: 1;
 /**
  * 分区注册表（**Record<SectionId, SectionMeta>**：漏注册/写错 id → 编译失败）。