dsh-config-manager 0.1.71 → 0.1.72

package/src/index.ts

@@ -75,7 +75,13 @@ import { createRecoveryOrchestrator, type RecoveryExecutorFns } from './core/rec
 import { JournalStore } from './core/journal.ts'
 import { RunRegistry, type RunState } from './core/run-registry.ts'
 import { registerModelTools } from './core/model-tools.ts'
-import { makeMsg, msgOf, zhMsg } from './core/messages.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 type { RollbackForkCarrier, RollbackRewindResult } from './core/rollback-point.ts'
+// t3：宿主斜杠命令 /rollback（与 HTTP 路由同一道写入门；命令服务惰取，未组合时安静跳过）。
+import { agentSessionFactsOf, registerRollbackCommand } from './core/command-rollback.ts'
+import type { CommandServiceLike, RollbackCommandHost } from './core/command-rollback.ts'
 import type { MsgFunc } from './core/messages.ts'
 import { cleanupAbortedInstall, hasDshBundlePatch, installAnchorFromProfileContext, installErrorFor, installSpecFor, listInstalledPlugins, profileNameFromProfileContext, resolveProcessProfileName, resolveProfileDir, readProfileManifest, runDshPlugin, validateProfileName } from './core/plugin-cli.ts'
 import type { ConfigAdapter, CredentialsFacade, ExportUnit, FileSystemFacade, HostContext, ImportDecisions, ImportPlan, NamedNamespaceInfo, NamespaceInfo, PatchFileFacade, PlanItemKind, PluginInfo, PluginsFacade, SessionMoveResult, SessionParentRelation, SessionRewriteResult, SessionStoreFacade, SettingsFacade, SkillDefinitionView, SkillStoreFacade, SkillSummaryView, WorkspaceFacade } from './core/types.ts'
@@ -89,7 +95,8 @@ import { createLocalPluginPackHook } from './core/local-plugin-host.ts'
 import { ENCRYPTED_CONTAINER_CODE, createEncryptionProvider, decryptCredentials, readContainerKind, SecurityError, encryptArchive } from './security/index.ts'
 import { createHardenedZipParser } from './security/zip-security.ts'
 import { collectCredentialRefs } from './security/credentials-yaml.ts'
-import { applySessionMeta, applySessionMetaToPlanItems, applySessionParentLinks, readSessionMeta, subagentParentMap } from './core/session-meta.ts'
+import { applySessionMeta, applySessionMetaToPlanItems, applySessionParentLinks, readSessionMeta, readSessionMetaWithTitles, subagentParentMap } from './core/session-meta.ts'
+import type { SessionMetaIndex } from './core/session-meta.ts'
 import { projectKeyOf, sessionIdKey } from './core/session-select.ts'
 import { PROJECT_KEY_RE, readLogCwdFromBytes, rewriteSessionLogDir } from './utils/session-log.ts'
 import { probeSessionFormats, resolveSessionFormatVersion } from './utils/session-format.ts'
@@ -101,10 +108,11 @@ import { activeProxySummary } from './utils/proxy.ts'
 import { listRecursiveFollowingLinks } from './utils/recursive-walk.ts'
 import { Phase3Recovery, TransactionRecoveryRequiredError, mapLockStateForStartup } from './core/phase3-host.ts'
 import type { JournalRunContext } from './core/phase3-host.ts'
-import { classifyStartup, FAIL_CLOSED_STARTUP } from './core/startup-barrier.ts'
+import { classifyStartup, FAIL_CLOSED_STARTUP, resolveStartupSafeMode } from './core/startup-barrier.ts'
 import type { MutationLockPort } from './utils/env-lock.ts'
 import type { RecursiveListing } from './utils/recursive-walk.ts'
 import { GitTransport } from './sync/git/git-transport.ts'
+import type { GitWorkDirFacts } from './sync/git/git-transport.ts'
 import { WebDavTransport } from './sync/webdav/webdav-transport.ts'
 import { S3Transport } from './sync/s3/s3-transport.ts'
 import { GistTransport } from './sync/gist/gist-transport.ts'
@@ -131,7 +139,7 @@ import {
 } from './routes/session-format.ts'
 import type { SessionFormatDisposition } from './core/types.ts'
 import type { SyncConfig, SyncTransportType } from './sync/sync-config.ts'
-import { defaultSyncSelection, effectiveSections, normalizeSessionsInclude, OPT_IN_SYNC_SECTIONS, readAllSyncSelections, readSyncSelection } from './sync/sync-selection.ts'
+import { AUTO_SYNC_OPT_IN_SECTIONS, defaultSyncSelection, effectiveSections, normalizeSessionsInclude, OPT_IN_SYNC_SECTIONS, readAllSyncSelections, readSyncSelection } from './sync/sync-selection.ts'
 import type { SyncSelection, SyncSelectionMode } from './sync/sync-selection.ts'
 import type { SyncTransport } from './sync/transport.ts'
 import { GitMarketReader } from './market/reader.ts'
@@ -166,7 +174,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.71'
+export const PLUGIN_VERSION = '0.1.72'
 
 /** Plugin own package name — excluded from its own exported plugins list. */
 const PLUGIN_NAME = 'dsh-config-manager'
@@ -231,7 +239,7 @@ export interface Config {
 /**
  * 本文件保留的 7 条路由的路径（被源码级守卫按文件窗口钉住，见下方 routesList 注释）。
  *
- * 其余 71 条路由的路径**声明在各自的组文件里**（src/routes/*.ts 的 endpoint({ path, methods })）——
+ * 其余 72 条路由的路径**声明在各自的组文件里**（src/routes/*.ts 的 endpoint({ path, methods })）——
  * 新增一条 API 只需那一条声明，不再有「常量表 + 路由对象」两处要同步。
  */
 export const API = {
@@ -815,6 +823,149 @@ const SESSION_STORE_PURPOSE_KEY: Record<SessionStorePurpose, string> = {
  */
 const PARENT_RELATIONS_CACHE_TTL_MS = 5_000
 
+/**
+ * `ancestorSessionIds` 的上溯深度上限。
+ *
+ * 取 8：DSH 的子代理树实际深度是个位数（`delegationDepth`），8 层足够覆盖「子代理的子代理」；
+ * 上限 + 环保护一道，保证异常数据（自指 / 环）不会把回退路径卡死。
+ */
+const ANCESTOR_LOOKUP_MAX_DEPTH = 8
+
+/**
+ * 宿主会话管理面（`SessionController`）的结构窄化 —— 本仓 core 不 import `@deepseek-ai/*`。
+ *
+ * `fork(request)` = DSH 自己的「从某条事件前缀分叉」命令（内部 `SessionCommandController.fork`）：
+ * 建 agent + 落盘 + 挂回原工作区一次到位，返回新子会话 id。**这是回退唯一可用的 fork 路径**
+ * （底层 `SessionStore.fork` 造的会话没有 agent、不落盘，见 forkSession 注释）。
+ */
+interface SessionForkController {
+  fork?: (request: { sessionId: string; atSeq: number }) => Promise<unknown>
+}
+
+/** `ctx.get('workspaceRegistry')` 的结构窄化（本仓 core 不 import @deepseek-ai/*）。 */
+interface WorkspaceRegistryLike {
+  list?: () => unknown
+  /** DSH 的「按规范目录路径解析工作区」：目录不存在时在 realpath 阶段拒绝；目录存在但无人认领返回 undefined。 */
+  resolveByPath?: (path: string) => Promise<unknown>
+}
+
+/** 归位成功的两种情形（都经 `list()` 复核过）。 */
+export type WorkspaceAttachSuccessReason =
+  /** 官方 fork 已经归位（能按成员/血缘解析到工作区）——本兜底只补复核，不重复写。 */
+  | 'already-attached'
+  /** 本兜底真的写成功且复核通过。 */
+  | 'attached'
+
+/**
+ * 归位失败的具体理由（机器码）。
+ *
+ * 为什么必须区分而不是一个笼统的 `false`：真机现场「回退后子会话进未分组」长期不可见，
+ * 根因之一就是 attach 失败被吞成布尔（无日志、无理由）。每一档都能单独定位：
+ *  · registry-unavailable / registry-list-unavailable / registry-list-failed —— 服务缺失或形状不符；
+ *  · attach-session-missing —— 工作区记录上**没有** `attachSession`（形状不符，未发起任何写）；
+ *  · attach-rejected —— `attachSession` 真的抛错（目录不存在 / cwd 对不上 / 域未就绪）；
+ *  · directory-missing —— `resolveByPath` 在 realpath 阶段拒绝，或回落档 realpath 失败（目录不存在）；
+ *  · no-workspace-for-cwd —— 目录存在但不属于任何已注册工作区；
+ *  · cwd-unavailable —— 读不到子会话 cwd（绝不猜路径）；
+ *  · verify-failed —— 写调用没抛错，但 `list()` 复核不含该子会话（最终判据不通过，**不许报成功**）；
+ *  · unexpected-error —— 其它未预期异常。
+ */
+export type WorkspaceAttachFailureReason =
+  | 'registry-unavailable'
+  | 'registry-list-unavailable'
+  | 'registry-list-failed'
+  | 'attach-session-missing'
+  | 'attach-rejected'
+  | 'directory-missing'
+  | 'no-workspace-for-cwd'
+  | 'cwd-unavailable'
+  | 'verify-failed'
+  | 'unexpected-error'
+
+/** 归位失败（`detail` 是技术细节：errno / 路径 / 形状码，供日志与排查，不是用户文案）。 */
+export interface WorkspaceAttachFailure {
+  ok: false
+  reason: WorkspaceAttachFailureReason
+  detail?: string
+}
+
+/** 一次 `attachSession` 尝试（只表达「写调用是否成功」，最终判据在 {@link DshSessionStoreFacade} 的复核里）。 */
+type AttachAttempt = { ok: true } | { ok: false; reason: 'attach-session-missing' | 'attach-rejected'; detail?: string }
+
+/** 一次工作区归位的结果（成功/失败都带**具体**理由）。 */
+export type WorkspaceAttachOutcome =
+  | { ok: true; reason: WorkspaceAttachSuccessReason; workspaceId?: string }
+  | WorkspaceAttachFailure
+
+/** 归位失败时给调用方的 warning 串（稳定前缀 + 具体理由码）。 */
+export const WORKSPACE_ATTACH_FAILED_PREFIX = 'workspace-attach-failed'
+
+/**
+ * DSH 官方 fork 在「子会话已创建、但 `workspace.attachSession` 失败」时抛的错误码。
+ *
+ * 依据 DSH 源码：`dsh-api-session-controller/lib/index.js` L829-836 抛
+ * `new RemoteError('session/workspace-attach-failed', …, { sessionId: childId, workspaceId })`。
+ */
+export const WORKSPACE_ATTACH_FAILED_ERROR_CODE = 'session/workspace-attach-failed'
+
+/**
+ * 从官方 fork 的 `session/workspace-attach-failed` 错误里取回**已经创建好的子会话 id**。
+ *
+ * 字段名**不是猜的** —— DSH 自己的客户端就是这么取的（同款姿势）：
+ * `dsh-api-session-controller/lib/client.js` L3013-3015 的 `workspaceAttachSessionId(error)`：
+ *   `error.code === 'session/workspace-attach-failed' ? error.details.sessionId : undefined`
+ * 错误类是 `dsh-typert-protocol/lib/index.js` L11-28 的 `RemoteError`（`code` + `details`；
+ * DSH 明文规定「判别只按 code，never by instanceof」，故这里也只按 `code`，不 import 那门包）。
+ *
+ * 形状不符（不是对象 / code 不是这个 / 没有 details.sessionId / 空串）一律 undefined ——
+ * 调用方据此**保持现状**报 fork-failed，绝不假装成功、也绝不猜别的字段名。
+ */
+export function workspaceAttachFailureChildId(error: unknown): string | undefined {
+  if (error === null || typeof error !== 'object') return undefined
+  const code = (error as { code?: unknown }).code
+  if (code !== WORKSPACE_ATTACH_FAILED_ERROR_CODE) return undefined
+  const details = (error as { details?: unknown }).details
+  if (details === null || typeof details !== 'object') return undefined
+  const sessionId = (details as { sessionId?: unknown }).sessionId
+  return typeof sessionId === 'string' && sessionId !== '' ? sessionId : undefined
+}
+
+/**
+ * 归位失败 → warning 串；成功 → undefined。
+ *
+ * 为什么是「前缀:理由码」而不是新字段：`RollbackForkSeam`（core/types.ts，本任务 scope 外）的返回
+ * 形状只有 `{ childSessionId, warning? }`，warning 是**唯一**能把具体理由带到调用方的通道；
+ * core 只判「非空」并落成 `rollback.guidance.sessionNotAttached`（界面如实上屏），
+ * 前缀保持稳定以便既有 grep / 诊断脚本继续命中。
+ */
+export function workspaceAttachWarningOf(outcome: WorkspaceAttachOutcome): string | undefined {
+  return outcome.ok ? undefined : WORKSPACE_ATTACH_FAILED_PREFIX + ':' + outcome.reason
+}
+
+/**
+ * 目录同一性比较用的折叠（**只在 `resolveByPath` 拿不到时的回落档**使用）。
+ *
+ * 分隔符统一为 `/`；win32 大小写不敏感（Windows 路径大小写等价）。
+ * 注意：本函数只比较**两侧都经 realpath 规范化**过的路径 —— 绝不拿「原样 cwd」与「规范 path」直接比，
+ * 那正是真机 2026-10-12 的根因（工作区 path 经 `realpathNormalize`、会话头 cwd 是原样字符串）。
+ */
+export function foldWorkspacePath(value: string): string {
+  const unified = value.replace(/\\/g, '/')
+  return process.platform === 'win32' ? unified.toLowerCase() : unified
+}
+
+/** 工作区记录的稳定 id（形状不符 → undefined；只作诊断/日志，不参与判定）。 */
+function workspaceRecordIdOf(record: Record<string, unknown>): string | undefined {
+  const id = record['id']
+  return typeof id === 'string' && id !== '' ? id : undefined
+}
+
+/** 该记录是否把某会话算作成员（`sessionIds` 非数组 = 形状不符，不算成员）。 */
+function recordHasMember(record: Record<string, unknown>, sessionId: string): boolean {
+  const sessionIds = record['sessionIds']
+  return Array.isArray(sessionIds) && sessionIds.includes(sessionId)
+}
+
 export class DshSessionStoreFacade implements SessionStoreFacade {
   private readonly ctx: Context
   /** DSH 缺省会话根（配置改过时只影响快路径命中率，慢路径仍正确） */
@@ -834,12 +985,373 @@ export class DshSessionStoreFacade implements SessionStoreFacade {
   private readonly log: Logger
   /** 文案翻译器（F-1 的形状异常诊断走字典，禁止硬编码用户可见字符串） */
   private readonly msgFunc: MsgFunc
+  /**
+   * 目录规范化（t10）：工作区归位第 ③ 档的**回落**比较用。
+   *
+   * 缺省 = `node:fs/promises` 的 `realpath`（与 DSH 的 `realpathNormalize` 同一套系统调用）；
+   * 可注入是为了让「大小写/短名/分隔符不同」这条判定能被**确定性**单测覆盖（不依赖真实盘符/短名）。
+   */
+  private readonly realpath: (path: string) => Promise<string>
 
-  constructor(ctx: Context, homeDir: string, msg: MsgFunc = zhMsg, log?: Logger) {
+  constructor(ctx: Context, homeDir: string, msg: MsgFunc = zhMsg, log?: Logger, realpath?: (path: string) => Promise<string>) {
     this.ctx = ctx
     this.root = join(homeDir, 'sessions')
     this.log = log ?? createLogger({ level: 'warn' })
     this.msgFunc = msg
+    this.realpath = realpath ?? (async (value: string): Promise<string> => await fs.realpath(value))
+  }
+
+  /**
+   * 回退到稳定边界的**子会话**（S3：工作区 + 会话回滚）。
+   *
+   * 走 **DSH 自己的 fork 路径**：`ctx.get('sessionController').fork({ sessionId, atSeq })`
+   * （宿主 `SessionController.fork` → `SessionCommandController.fork`；惰取服务，**绝不**属性访问
+   * `ctx.sessionController` —— 未声明 inject 时属性访问会抛错并致宿主启动崩溃）。
+   *
+   * 为什么**必须**走它、而不能直接调底层 `SessionStore.fork`（真机 2026-10-12 定案）：
+   *  · 官方路径用 `ctx.agents.create(...)` 建子会话 ⇒ 子会话有 agent、**会落盘**、id 是 uuid；
+   *    它**会尝试**挂回工作区，但只按「成员/血缘」两档解析（见 `attachChildToParentWorkspace` 的
+   *    事实锁定）——解析不到就**不归位**；
+   *  · 底层 `SessionStore.fork` 只在内存 store 里造一条会话记录（id 还是进程内计数 `session-1`），
+   *    没有 agent、没有持久化 ⇒ 用户回退后想继续对话时，宿主 `resolve → resume →
+   *    sessionQuery.observeSession` 在磁盘上找不到它，界面直接报
+   *    `resume failed for session "session-1": SessionPersistenceNotFoundError`（用户截图 2026-10-12）。
+   *
+   * 契约：**任何异常与任何形状不符都收成 `{ error }`**，调用方必须如实结构化降级
+   * （`fork-failed` 等），绝不静默假装成功。
+   *
+   * **唯一的例外（t16）：官方 fork 的 attach 失败不算 fork 失败。** 那时 `SessionCommandController.fork`
+   * 已经建好子会话（uuid + 落盘），只是 `workspace.attachSession` 抛了错 —— 它把整件事报成
+   * `session/workspace-attach-failed`（细节带 childId）。旧实现把它整体收成 `{ error }` ⇒ 引擎报
+   * fork-failed ⇒ 用户看到「回退失败」，而磁盘上却多出一条「未分组」的子会话。现在：
+   * 从错误里**按 DSH 客户端同款字段**取回 childId（见 workspaceAttachFailureChildId），
+   * 取到 ⇒ 不再报失败，改由 attachChildToParentWorkspace 兜底归位；取不到 ⇒ 保持现状报失败。
+   *
+   * 工作区归位：官方能解析到工作区时它已经写过（本方法只复核）；解析不到（官方缺同目录档）才由
+   * attachChildToParentWorkspace 兜底写。**归位失败一定带具体理由**：日志留痕 + warning 串
+   * 形如 `workspace-attach-failed:<reason>`（core 落成 `rollback.guidance.sessionNotAttached` 如实上屏）。
+   */
+  async forkSession(sessionId: string, boundarySeq: number): Promise<{ childSessionId: string; warning?: string } | { error: string }> {
+    let childId: string | undefined
+    try {
+      const controller = readService<SessionForkController>(this.ctx, 'sessionController')
+      const fork = controller?.fork
+      if (typeof fork !== 'function') return { error: 'session-controller-unavailable' }
+      const child = await fork.call(controller, { sessionId, atSeq: boundarySeq })
+      const id = child !== null && typeof child === 'object' ? (child as { sessionId?: unknown }).sessionId : undefined
+      if (typeof id !== 'string' || id === '') return { error: 'fork-returned-no-id' }
+      childId = id
+    } catch (error) {
+      // t16：官方 fork 在 attach 失败时抛 session/workspace-attach-failed —— 子会话**已经建好**，
+      // 只是没归位。把它整体报成 fork-failed 会让用户以为回退失败，而盘上多出一条「未分组」的子会话。
+      // 字段名按 DSH 自己的客户端同款姿势取（见 workspaceAttachFailureChildId 的注释），**不猜**。
+      const recovered = workspaceAttachFailureChildId(error)
+      if (recovered === undefined) return { error: errorMessage(error) }
+      this.log.warn(
+        'rewind: fork reported ' + WORKSPACE_ATTACH_FAILED_ERROR_CODE + '; keeping child session ' + recovered
+        + ' (the session was created, only the workspace attach failed)',
+      )
+      childId = recovered
+    }
+    // 工作区归位：官方已归位 → 只复核；官方没归位（或 attach 抛错被上面救回）→ 本兜底写；写后一律复核。
+    const outcome = await this.attachChildToParentWorkspace(sessionId, childId)
+    if (outcome.ok) {
+      this.log.info(
+        'rewind: child session filed into workspace: ' + childId + ' (' + outcome.reason + (outcome.workspaceId !== undefined ? ' ' + outcome.workspaceId : '') + ')',
+      )
+      return { childSessionId: childId }
+    }
+    // 归位失败**带具体理由**（绝不静默）：日志留痕 + warning 串交给调用方如实上屏。
+    this.log.warn(
+      'rewind: child session not filed into any workspace: ' + childId + ' reason=' + outcome.reason
+      + (outcome.detail !== undefined ? ' detail=' + outcome.detail : ''),
+    )
+    const warning = workspaceAttachWarningOf(outcome)
+    return warning === undefined ? { childSessionId: childId } : { childSessionId: childId, warning }
+  }
+
+  /**
+   * 把 fork 出来的子会话挂回**原会话所属工作区**（只读匹配 + 官方写 + 复核）。
+   *
+   * 三档判定，每一档都只相信 DSH 自己的成员语义（真正的成员判据是
+   * “子会话 header 的 canonical cwd === 工作区 path”，`attachSession` 落盘前会再复核一次）：
+   *  ① **直接命中**：某工作区的 `sessionIds` 含原会话 —— 与 DSH `forkWorkspace` 第一档同口径；
+   *  ② **血缘**：原会话是子代理会话时，它的**祖先**才在某个工作区里 —— DSH `forkWorkspace`
+   *     对 `origin === 'subagent'` 正是沿 `parentSession` 链上溯（有环保护 + 深度上限）；
+   *  ③ **同目录**：子会话 header 的 cwd 与某工作区的 `path` 指向**同一个目录** —— 这正是 DSH 的成员判据本身。
+   *     目录同一性**由 DSH 判定**：优先 `workspaceRegistry.resolveByPath(cwd)`（异步、按注册表同一套
+   *     realpath 规范化、目录不存在直接在 realpath 阶段拒绝）；拿不到该方法才回落「双端 realpath +
+   *     win32 大小写折叠」。**绝不**用未归一化的裸字符串比较 —— 真机 2026-10-12 的根因正是它：
+   *     工作区 path 经 `realpathNormalize`、会话头 cwd 是原样字符串，Windows 上大小写 / 短名 / 分隔符任一
+   *     不同即判不相等 ⇒ 三档全落空 ⇒ 子会话永久停在「未分组」，且失败被吞成布尔、一直不可见。
+   *
+   * **官方 fork 是否已自带归位（要求 D 的事实锁定，依据 DSH 源码）**：
+   *  · `dsh-api-session-controller/lib/index.js` 的 `SessionCommandController.fork` 会先调
+   *    `forkWorkspace(source.header)`（L802）再 `workspace.attachSession(childId)`（L829-836），
+   *    attach 失败时抛 `session/workspace-attach-failed`（错误细节带 childId）；
+   *  · 但 `forkWorkspace`（L1036-1045）**只有两档**：`sessionIds` 直接命中、`origin==='subagent'` 时沿
+   *    祖先上溯 —— **没有同目录档**；两档都落空就返回 undefined ⇒ 官方**不归位**（本机现场：
+   *    父会话不属于那 8 个工作区中的任何一个，于是每次回退都留下「未分组」的子会话）。
+   *  结论：官方能解析到工作区时**它已经写了**，本兜底只补最后一道复核（`already-attached`）；
+   *  官方解析不到（缺同目录档）才由本兜底的 ③ 档写 —— **不重复写、也不两处都写**。
+   *
+   * 任一档写失败（工作区目录已不存在 / cwd 对不上 / 形状不符）**只换下一档继续找**；三档都拿不到才返回带
+   * **具体理由**的失败（调用方经 warning 通道如实上屏 + 日志留痕）—— **绝不猜、也绝不假装已归位**。
+   */
+  private async attachChildToParentWorkspace(parentId: string, childId: string): Promise<WorkspaceAttachOutcome> {
+    try {
+      const registry = readService<WorkspaceRegistryLike>(this.ctx, 'workspaceRegistry')
+      if (registry === undefined) return { ok: false, reason: 'registry-unavailable' }
+      const listed = this.registryRecordsOf(registry)
+      if (!listed.ok) return listed.failure
+      const records = listed.records
+
+      // 要求 D：官方 fork 已归位（能按成员/血缘解析到工作区）⇒ 这里**只补最后一道复核**，绝不重复写。
+      const already = this.workspaceRecordWithMember(records, childId)
+      if (already !== undefined) {
+        const workspaceId = workspaceRecordIdOf(already)
+        return workspaceId === undefined ? { ok: true, reason: 'already-attached' } : { ok: true, reason: 'already-attached', workspaceId }
+      }
+
+      /** 找到工作区但写失败的第一条理由（比「没找到工作区」更可操作，优先回报）。 */
+      let attachFailure: WorkspaceAttachFailure | undefined
+      /** ③ 档「找不到同目录工作区 / 目录不存在 / 读不到 cwd」的理由。 */
+      let cwdFailure: WorkspaceAttachFailure | undefined
+
+      // ① 直接命中（DSH forkWorkspace 的第一档）
+      const direct = this.workspaceRecordWithMember(records, parentId)
+      if (direct !== undefined) {
+        const attempt = await this.attachChildTo(direct, childId)
+        if (attempt.ok) return await this.verifyChildAttached(registry, childId)
+        attachFailure = attempt
+      }
+      // ② 血缘：子代理会话的祖先所属工作区（DSH forkWorkspace 对 subagent 的同款上溯）
+      for (const ancestorId of this.ancestorSessionIds(parentId)) {
+        const record = this.workspaceRecordWithMember(records, ancestorId)
+        if (record === undefined) continue
+        const attempt = await this.attachChildTo(record, childId)
+        if (attempt.ok) return await this.verifyChildAttached(registry, childId)
+        attachFailure ??= attempt
+      }
+      // ③ 同目录：cwd 与某工作区 path 指向同一目录（目录同一性由 DSH 判定，见方法注释）
+      const cwd = this.liveSessionCwd(childId)
+      if (cwd === undefined) {
+        cwdFailure = { ok: false, reason: 'cwd-unavailable' }
+      } else {
+        const resolution = await this.resolveWorkspaceByCwd(registry, records, cwd)
+        if (resolution.records !== undefined && resolution.records.length > 0) {
+          for (const record of resolution.records) {
+            const attempt = await this.attachChildTo(record, childId)
+            if (attempt.ok) return await this.verifyChildAttached(registry, childId)
+            attachFailure ??= attempt
+          }
+        } else {
+          cwdFailure = resolution.failure
+        }
+      }
+      return attachFailure ?? cwdFailure ?? { ok: false, reason: 'no-workspace-for-cwd' }
+    } catch (error) {
+      const detail = errorMessage(error)
+      this.log.warn('rewind: workspace attach failed: ' + detail)
+      return { ok: false, reason: 'unexpected-error', detail }
+    }
+  }
+
+  /**
+   * 读一次注册表列举：形状不符（没有 list / 返回非数组）与抛错**分开**报，绝不吞成一个 false。
+   */
+  private registryRecordsOf(
+    registry: WorkspaceRegistryLike,
+  ): { ok: true; records: readonly unknown[] } | { ok: false; failure: WorkspaceAttachFailure } {
+    const list = registry.list
+    if (typeof list !== 'function') return { ok: false, failure: { ok: false, reason: 'registry-list-unavailable', detail: 'list-not-a-function' } }
+    let raw: unknown
+    try {
+      raw = list.call(registry)
+    } catch (error) {
+      return { ok: false, failure: { ok: false, reason: 'registry-list-failed', detail: errorMessage(error) } }
+    }
+    if (!Array.isArray(raw)) return { ok: false, failure: { ok: false, reason: 'registry-list-unavailable', detail: 'list-not-array' } }
+    return { ok: true, records: raw }
+  }
+
+  /** 列举里第一个 `sessionIds` 含该会话的工作区记录（形状不符一律跳过，绝不猜）。 */
+  private workspaceRecordWithMember(records: readonly unknown[], sessionId: string): Record<string, unknown> | undefined {
+    for (const raw of records) {
+      if (raw === null || typeof raw !== 'object') continue
+      const record = raw as Record<string, unknown>
+      if (recordHasMember(record, sessionId)) return record
+    }
+    return undefined
+  }
+
+  /**
+   * 对一条工作区记录调官方 `attachSession(childId)`，并返回**具体理由**（绝不静默返回 false）。
+   *
+   * `attach` 必须 `.call(record, ...)` 保留 receiver（实体方法内部用 `this.host` / `this.record`）。
+   * 两种失败**分开**：记录上根本没有 `attachSession`（形状不符，未发起任何写）vs 真的抛错（写被拒）。
+   */
+  private async attachChildTo(record: Record<string, unknown>, childId: string): Promise<AttachAttempt> {
+    const attach = record['attachSession']
+    if (typeof attach !== 'function') {
+      const detail = 'workspace-record-has-no-attachSession'
+      this.log.warn('rewind: workspace attach skipped for ' + childId + ': ' + detail)
+      return { ok: false, reason: 'attach-session-missing', detail }
+    }
+    try {
+      await (attach as (this: unknown, id: string) => Promise<void>).call(record, childId)
+      return { ok: true }
+    } catch (error) {
+      const detail = errorMessage(error)
+      this.log.warn('rewind: workspace attach rejected for ' + childId + ': ' + detail)
+      return { ok: false, reason: 'attach-rejected', detail }
+    }
+  }
+
+  /**
+   * ③ 档：cwd 指向的**已注册工作区**记录（目录同一性由 DSH 判定，绝不裸字符串比较）。
+   *
+   * 优先 DSH 自己的 `resolveByPath(cwd)`：
+   *  · 它按注册表同一套 realpath 规范化（Windows 大小写 / 短名 / 分隔符差异都能对上）；
+   *  · **目录不存在时它在 realpath 阶段拒绝** —— 那正是「目录不存在」的判定，如实转成 `directory-missing`；
+   *  · 目录存在但不属于任何工作区 → 返回 undefined（`no-workspace-for-cwd`）；
+   *  · 返回的工作区实体自带 `attachSession`，直接用它（就是 DSH 判定的那一个目录，不需要再按字符串回查）。
+   * 拿不到该方法（老宿主 / 形状不符）才回落 {@link resolveWorkspaceByCwdFallback}。
+   */
+  private async resolveWorkspaceByCwd(
+    registry: WorkspaceRegistryLike,
+    records: readonly unknown[],
+    cwd: string,
+  ): Promise<{ records: readonly Record<string, unknown>[]; failure?: undefined } | { records?: undefined; failure: WorkspaceAttachFailure }> {
+    const resolveByPath = registry.resolveByPath
+    if (typeof resolveByPath !== 'function') return await this.resolveWorkspaceByCwdFallback(records, cwd)
+    let resolved: unknown
+    try {
+      resolved = await resolveByPath.call(registry, cwd)
+    } catch (error) {
+      const detail = errorMessage(error)
+      this.log.warn('rewind: resolveByPath rejected for ' + cwd + ': ' + detail)
+      return { failure: { ok: false, reason: 'directory-missing', detail } }
+    }
+    if (resolved === undefined || resolved === null) return { failure: { ok: false, reason: 'no-workspace-for-cwd', detail: cwd } }
+    if (typeof resolved !== 'object') {
+      return { failure: { ok: false, reason: 'registry-list-unavailable', detail: 'resolveByPath-returned-non-object' } }
+    }
+    const entity = resolved as Record<string, unknown>
+    if (typeof entity['attachSession'] !== 'function') {
+      return { failure: { ok: false, reason: 'attach-session-missing', detail: 'resolveByPath-result-has-no-attachSession' } }
+    }
+    return { records: [entity] }
+  }
+
+  /**
+   * ③ 档回落（`resolveByPath` 不可用）：**双端** realpath + win32 大小写折叠比较。
+   *
+   * 两侧都必须 realpath 过才比：cwd 侧失败 = 目录不存在（`directory-missing`）；工作区侧失败 =
+   * 该工作区目录已不在（**跳过它**，不猜「像同一个」）。
+   */
+  private async resolveWorkspaceByCwdFallback(
+    records: readonly unknown[],
+    cwd: string,
+  ): Promise<{ records: readonly Record<string, unknown>[]; failure?: undefined } | { records?: undefined; failure: WorkspaceAttachFailure }> {
+    let cwdCanonical: string
+    try {
+      cwdCanonical = await this.realpath(cwd)
+    } catch (error) {
+      const detail = errorMessage(error)
+      this.log.warn('rewind: realpath failed for ' + cwd + ': ' + detail)
+      return { failure: { ok: false, reason: 'directory-missing', detail } }
+    }
+    const folded = foldWorkspacePath(cwdCanonical)
+    const matches: Record<string, unknown>[] = []
+    for (const raw of records) {
+      if (raw === null || typeof raw !== 'object') continue
+      const record = raw as Record<string, unknown>
+      const path = record['path']
+      if (typeof path !== 'string' || path === '') continue
+      let candidate: string
+      try {
+        candidate = await this.realpath(path)
+      } catch {
+        continue
+      }
+      if (foldWorkspacePath(candidate) === folded) matches.push(record)
+    }
+    // 同一目录理论上只有一条记录（DSH 的 createCanonical 保证）；仍逐条返回，让调用方对失败的那条换下一条试。
+    return matches.length === 0 ? { failure: { ok: false, reason: 'no-workspace-for-cwd', detail: cwd } } : { records: matches }
+  }
+
+  /**
+   * 归位后的**复核**（要求 C）：`list()` 里该工作区的 `sessionIds` 是否真的包含子会话。
+   *
+   * 为什么必须复核：`sessionIds` 由 DSH 按 `sessionPath(id) === record.path` 过滤（dsh-workspace
+   * 实体 getter），是「这个会话到底归没归位」的**最终判据**；attach 返回成功只代表那次写调用没抛错。
+   * 复核不通过一律按失败处理并给出理由 —— **不许报成功**。
+   */
+  private async verifyChildAttached(registry: WorkspaceRegistryLike, childId: string): Promise<WorkspaceAttachOutcome> {
+    const listed = this.registryRecordsOf(registry)
+    if (!listed.ok) {
+      const detail = listed.failure.reason + (listed.failure.detail !== undefined ? ':' + listed.failure.detail : '')
+      this.log.warn('rewind: workspace attach verify could not list workspaces for ' + childId + ': ' + detail)
+      return { ok: false, reason: 'verify-failed', detail }
+    }
+    const record = this.workspaceRecordWithMember(listed.records, childId)
+    if (record === undefined) {
+      const detail = 'child-not-in-any-workspace-sessionIds'
+      this.log.warn('rewind: workspace attach verify failed for ' + childId + ': ' + detail)
+      return { ok: false, reason: 'verify-failed', detail }
+    }
+    const workspaceId = workspaceRecordIdOf(record)
+    return workspaceId === undefined ? { ok: true, reason: 'attached' } : { ok: true, reason: 'attached', workspaceId }
+  }
+
+  /**
+   * 从**活的**会话存储沿 `parentSession` 上溯祖先 id（不含起点；有环保护与深度上限）。
+   *
+   * 读不到会话 / 读不到 header / 形状不符一律停在这一层返回已收集的祖先 —— 这是只读探测，
+   * 宁少不猜（DSH 官方用 `sessionQuery.traceSession`；这里只依赖 `sessions.get(id).header`）。
+   */
+  private ancestorSessionIds(sessionId: string): string[] {
+    const out: string[] = []
+    const seen = new Set<string>([sessionId])
+    let current = sessionId
+    for (let depth = 0; depth < ANCESTOR_LOOKUP_MAX_DEPTH; depth += 1) {
+      const header = this.liveSessionHeader(current)
+      const parent = header?.['parentSession']
+      if (typeof parent !== 'string' || parent === '' || seen.has(parent)) break
+      seen.add(parent)
+      out.push(parent)
+      current = parent
+    }
+    return out
+  }
+
+  /** 子会话 header 的 cwd（只读；读不到返回 undefined，绝不猜路径）。 */
+  private liveSessionCwd(sessionId: string): string | undefined {
+    const cwd = this.liveSessionHeader(sessionId)?.['cwd']
+    return typeof cwd === 'string' && cwd !== '' ? cwd : undefined
+  }
+
+  /**
+   * 活会话 header（`ctx.get('sessions').get(id).header`）。
+   *
+   * 形状不符（服务未挂载 / 会话不活）返回 undefined —— 与 DSH 的 `readSessionHeader` 第一优先
+   * 同源（它也是先看活会话，再看落盘列举）；这里不做落盘回落，避免把「文件系统上的旧 header」
+   * 当成「这次 fork 的孩子」。
+   */
+  private liveSessionHeader(sessionId: string): Record<string, unknown> | undefined {
+    const service = readService<{ get?: (id: string) => unknown }>(this.ctx, 'sessions')
+    const get = service?.get
+    if (typeof get !== 'function') return undefined
+    let session: unknown
+    try {
+      session = get.call(service, sessionId)
+    } catch {
+      return undefined
+    }
+    if (session === null || typeof session !== 'object') return undefined
+    const header = (session as { header?: unknown }).header
+    return header !== null && typeof header === 'object' ? header as Record<string, unknown> : undefined
   }
 
   /**
@@ -1484,8 +1996,10 @@ export class ConfigManagerHostContext implements HostContext {
   readonly profileDir: string
   readonly log: Logger
   readonly msg: MsgFunc
-  /** 应用语言（resolveAppLanguage；导出历史报告 locale 用） */
-  readonly language: 'zh' | 'en'
+  /** 应用语言（**调用期解析**：resolveAppLanguage 的活源；导出历史报告 locale 用） */
+  get language(): 'zh' | 'en' {
+    return getEngineLocale()
+  }
   readonly settings: SettingsFacade
   readonly credentials: CredentialsFacade
   readonly plugins: PluginsFacade
@@ -1540,8 +2054,15 @@ export class ConfigManagerHostContext implements HostContext {
       dshPackageJsonCandidates(homeDir, profile, installAnchor), sessionFormatTried)
     this.profile = profile
     this.profileDir = resolveProfileDir(homeDir, profile)
-    this.language = resolveAppLanguage(ctx)
-    this.msg = makeMsg(this.language)
+    // 引擎语言运行时（t2）：语言必须在「取文案那一刻」解析，而不是在装配那一刻 ——
+    // 原先 this.msg = makeMsg(resolveAppLanguage(ctx)) 只在 apply() 时求值一次，用户切到
+    // English 后宿主产出的报告/计划/错误文本永远停在加载时语言。
+    // 构造期先按当前语言设定一次（未设定时行为等于 zh），再注册「调用期解析」的活源：
+    // 之后每次取文案都跟随用户语言（resolveAppLanguage 走 ctx.settings.describe，
+    // 非请求路径由 LANGUAGE_TTL_MS 兜底缓存）。
+    setEngineLocale(resolveAppLanguage(ctx))
+    setEngineLanguageSource(() => resolveAppLanguage(ctx))
+    this.msg = engineMsg
     // 日志级别缺省 warn：启动 dsh web 后控制台只留 warn/error —— 挂载横幅、调度器跳过、
     // 导出/备份完成等常规 info 不再刷屏（用户要求移除启动后的日志噪音）；
     // 排查时 DSH_CONFIG_MANAGER_LOG_LEVEL=info|debug 恢复逐条输出。
@@ -1549,9 +2070,10 @@ export class ConfigManagerHostContext implements HostContext {
     if (this.sessionFormatVersion === undefined) {
       // 绝不静默：解析不到就明说体检不可用（用户仍能导出/导入，只是拿不到格式告警），
       // 并把已尝试的路径一并给出。
+      const separator = this.msg('host.sessionFormatPathSeparator')
       const triedText = sessionFormatTried.length > 6
-        ? sessionFormatTried.slice(0, 6).join('、') + ' 等'
-        : sessionFormatTried.join('、')
+        ? this.msg('host.sessionFormatPathsTruncated', { paths: sessionFormatTried.slice(0, 6).join(separator) })
+        : sessionFormatTried.join(separator)
       this.log.warn('无法解析本机 DSH 的会话格式版本：导入/同步不做「会话格式是否可读」体检'
         + `（已尝试 ${sessionFormatTried.length} 处：${triedText}）`)
     }
@@ -1671,7 +2193,7 @@ export async function tryDecryptCredentials(
  * （见 W1 报告的重测配方），把结果落到这里；makeRoutes 里的 const routeEnv: RouteEnvInferred =
  * 注解保证两侧不漂移（新增依赖漏登记会在构造点报错）。
  */
-export type RouteEnvInferred = { sessionExportFetch: ((input: string, init: RequestInit) => Promise<Response>) | undefined; sessionExportPort: number | undefined; adapters: ConfigAdapter<unknown>[]; sessionHealth: { homeDir: string; targetFormatVersion: () => number | undefined; workspaceKeys: () => Promise<ReadonlySet<string>>; knownSessionIds: () => Promise<ReadonlySet<string>>; }; backupScheduler: BackupScheduler; bootSafetyAudit: () => Promise<BootSafetyReport>; cancelDecisionTimeoutMs: number; buildMarketSummary: (e: { url: string; addedAt: string; }) => Promise<MarketSummary>; credentials: CredentialProvider; dataDir: string; exportsDir: string; githubAuth: GitHubAuthClient; githubClientId: string | undefined; githubClientSecret: string | undefined; githubFlows: DeviceFlowStore; history: MigrationStore; host: ConfigManagerHostContext; itemCached: (url: string, itemId: string) => Promise<boolean>; knownSyncSectionIds: Set<SectionId>; makeImporter: () => Importer; makeMarketReader: () => GitMarketReader; makeRecoveryExecutors: (runId: string) => RecoveryExecutorFns; makeSyncEngine: (cfg: SyncConfig, engineOpts?: { includeOptInSections?: boolean; }) => SyncEngine; marketBootAutoRefreshed: { value: boolean; }; marketCacheIndex: (url: string) => string; marketDir: string; marketCacheItemDir: (url: string) => string; marketStarCache: StarCache; marketWorkDir: (url: string) => string; meGitHubRest: GitHubAuthRest; meService: MyRepoService; meTokenProvider: () => Promise<string>; msg: MsgFunc; prepareSync: (body: Record<string, unknown>) => Promise<SyncConfig>; profileLauncher: DshProfileLauncher; profileRuntime: DshProfileRuntimeRegistry; profiles: DshProfileManager; pruneStagedMarketZips: () => Promise<void>; readCachedIndexObj: (url: string) => Promise<MarketIndex | null>; recoveryOrchestrator: RecoveryOrchestrator; resolveSyncPassword: (ref: string) => Promise<string | undefined>; roots: string[]; runAbortControllers: Map<string, AbortController>; runCancels: Map<string, { signal: AbortController; settle: (d: 'rollback' | 'keep') => void; decided: boolean }>; runs: RunRegistry; scheduler: AutoSyncScheduler; selectionCache: Partial<Record<SyncTransportType, SyncSelection>>; selectionHasOptInSections: (channel: SyncTransportType) => boolean; selectionView: (channel: SyncTransportType) => Promise<SelectionView>; selectionViewByChannel: () => Promise<Record<SyncTransportType, SelectionView>>; snapshotEntrySections: (snapshotDir: string) => Promise<string[]>; snapshotsDir: string; syncCredentialsByChannelView: () => Promise<Record<SyncTransportType, { encryptPasswordConfigured: boolean; decryptPasswordConfigured: boolean; }>>; syncDir: string; syncPasswordConfigured: (ref: string) => Promise<boolean>; syncSectionCatalog: { id: SectionId; displayName: string; portability: Portability; defaultIncluded: boolean; }[]; syncSessions: SyncSessionStore; tmpDir: string; tryAppendHistory: (raw: { kind: MigrationKind; result: MigrationResult; sections: string[]; operationId?: string; snapshotId?: string; runId?: string; source: 'api' | 'autosync' | 'backup-scheduler' | 'recovery' | 'cli' | 'internal'; summary: string; error?: string; }) => Promise<string | undefined>; withMutationGate: (op: string, handler: (req: IncomingMessage, res: ServerResponse, lockCtx?: MutationLockContext, journalCtx?: JournalRunContext) => Promise<void>, opts?: { journaled?: boolean; deferredSnapshot?: boolean; }) => ((req: IncomingMessage, res: ServerResponse) => Promise<void>); selfUpdate: (targetVersion: string) => Promise<SelfUpdateOutcome>; writeItemCache: (url: string, itemId: string, manifestRaw: string, zipBytes: Uint8Array) => Promise<void>; }
+export type RouteEnvInferred = { sessionExportFetch: ((input: string, init: RequestInit) => Promise<Response>) | undefined; sessionExportPort: number | undefined; adapters: ConfigAdapter<unknown>[]; sessionHealth: { homeDir: string; targetFormatVersion: () => number | undefined; workspaceKeys: () => Promise<ReadonlySet<string>>; knownSessionIds: () => Promise<ReadonlySet<string>>; sessionMeta: (ids: readonly string[]) => Promise<SessionMetaIndex>; }; backupScheduler: BackupScheduler; bootSafetyAudit: () => Promise<BootSafetyReport>; cancelDecisionTimeoutMs: number; buildMarketSummary: (e: { url: string; addedAt: string; }) => Promise<MarketSummary>; credentials: CredentialProvider; dataDir: string; exportsDir: string; githubAuth: GitHubAuthClient; githubClientId: string | undefined; githubClientSecret: string | undefined; githubFlows: DeviceFlowStore; history: MigrationStore; host: ConfigManagerHostContext; itemCached: (url: string, itemId: string) => Promise<boolean>; knownSyncSectionIds: Set<SectionId>; makeImporter: () => Importer; makeMarketReader: () => GitMarketReader; makeRecoveryExecutors: (runId: string) => RecoveryExecutorFns; makeSyncEngine: (cfg: SyncConfig, engineOpts?: { optInSections?: readonly SectionId[]; }) => SyncEngine; marketBootAutoRefreshed: { value: boolean; }; marketCacheIndex: (url: string) => string; marketDir: string; marketCacheItemDir: (url: string) => string; marketStarCache: StarCache; marketWorkDir: (url: string) => string; meGitHubRest: GitHubAuthRest; meService: MyRepoService; meTokenProvider: () => Promise<string>; msg: MsgFunc; prepareSync: (body: Record<string, unknown>) => Promise<SyncConfig>; profileLauncher: DshProfileLauncher; profileRuntime: DshProfileRuntimeRegistry; profiles: DshProfileManager; pruneStagedMarketZips: () => Promise<void>; readCachedIndexObj: (url: string) => Promise<MarketIndex | null>; recoveryOrchestrator: RecoveryOrchestrator; resolveSyncPassword: (ref: string) => Promise<string | undefined>; roots: string[]; runAbortControllers: Map<string, AbortController>; runCancels: Map<string, { signal: AbortController; settle: (d: 'rollback' | 'keep') => void; decided: boolean }>; runs: RunRegistry; scheduler: AutoSyncScheduler; selectionCache: Partial<Record<SyncTransportType, SyncSelection>>; selectionOptInSections: (channel: SyncTransportType, onlyAuto?: boolean) => SectionId[]; selectionView: (channel: SyncTransportType) => Promise<SelectionView>; selectionViewByChannel: () => Promise<Record<SyncTransportType, SelectionView>>; snapshotEntrySections: (snapshotDir: string) => Promise<string[]>; snapshotsDir: string; syncCredentialsByChannelView: () => Promise<Record<SyncTransportType, { encryptPasswordConfigured: boolean; decryptPasswordConfigured: boolean; }>>; syncDir: string; syncPasswordConfigured: (ref: string) => Promise<boolean>; syncWorkDir: { inspect: (repoUrl: string) => Promise<{ facts: GitWorkDirFacts; } | { error: string; }>; rebuild: (repoUrl: string, mode: 'relink' | 'reclone') => Promise<GitWorkDirFacts>; }; syncSectionCatalog: { id: SectionId; displayName: string; portability: Portability; defaultIncluded: boolean; }[]; syncSessions: SyncSessionStore; tmpDir: string; tryAppendHistory: (raw: { kind: MigrationKind; result: MigrationResult; sections: string[]; operationId?: string; snapshotId?: string; runId?: string; source: 'api' | 'autosync' | 'backup-scheduler' | 'recovery' | 'cli' | 'internal'; summary: string; error?: string; }) => Promise<string | undefined>; withMutationGate: (op: string, handler: (req: IncomingMessage, res: ServerResponse, lockCtx?: MutationLockContext, journalCtx?: JournalRunContext) => Promise<void>, opts?: { journaled?: boolean; deferredSnapshot?: boolean; }) => ((req: IncomingMessage, res: ServerResponse) => Promise<void>); selfUpdate: (targetVersion: string) => Promise<SelfUpdateOutcome>; writeItemCache: (url: string, itemId: string, manifestRaw: string, zipBytes: Uint8Array) => Promise<void>; }
 
 /** 解密错误 → 用户可读文本：BAD_PASSWORD 只报「密码错误」（不泄内部细节），其余原文 */
 export function decryptErrorText(error: unknown, msg: MsgFunc): string {
@@ -1767,7 +2289,7 @@ export async function parseSyncBody(
       } catch (error) {
         const reason = error instanceof Error ? error.message : String(error)
         throw new SyncRouteError(
-          `WebDAV 口令写入 DSH credentials 失败：${reason}（请在 DSH 凭据管理里配置 ${SYNC_WEBDAV_CREDENTIAL_REF} 后重试）`,
+          engineMsg('host.syncWebdavPasswordWriteFailed', { reason, ref: SYNC_WEBDAV_CREDENTIAL_REF }),
         )
       }
     }
@@ -1789,7 +2311,7 @@ export async function parseSyncBody(
     } catch (error) {
       const reason = error instanceof Error ? error.message : String(error)
       throw new SyncRouteError(
-        `token 写入 DSH credentials 失败：${reason}（请在 DSH 凭据管理里配置 ${SYNC_CREDENTIAL_REF} 后重试）`,
+        engineMsg('host.syncTokenWriteFailed', { reason, ref: SYNC_CREDENTIAL_REF }),
       )
     }
   }
@@ -1809,7 +2331,7 @@ function syncStr(value: unknown): string {
 function cloudCredentialWriteError(ref: string, kind: string, error: unknown): SyncRouteError {
   const reason = error instanceof Error ? error.message : String(error)
   return new SyncRouteError(
-    kind + ' 写入 DSH credentials 失败：' + reason + '（请在 DSH 凭据管理里配置 ' + ref + ' 后重试）',
+    engineMsg('host.syncCredentialWriteFailed', { kind, reason, ref }),
     400,
     'cloud.credentialsWriteFailed',
   )
@@ -1854,7 +2376,7 @@ async function parseCloudS3Body(
     try {
       await deps.credentials.set(credentialRef(ref), secret)
     } catch (error) {
-      throw cloudCredentialWriteError(ref, 'S3 密钥', error)
+      throw cloudCredentialWriteError(ref, engineMsg('host.syncKindS3Secret'), error)
     }
   }
   return {
@@ -2064,6 +2586,9 @@ export async function buildAutosyncStatus(dir: string, channel: SyncTransportTyp
     ...(cfg.lastRunAt !== undefined ? { lastRunAt: cfg.lastRunAt } : {}),
     ...(cfg.lastRunStatus !== undefined ? { lastRunStatus: cfg.lastRunStatus } : {}),
     ...(cfg.lastRunMessage !== undefined ? { lastRunMessage: cfg.lastRunMessage } : {}),
+    // issue #79：跳过原因以**码**回传（界面本地化）；不再只留在 info 级日志里
+    ...(cfg.lastRunSkipReason !== undefined ? { lastRunSkipReason: cfg.lastRunSkipReason } : {}),
+    ...(cfg.lastRunSkipCount !== undefined ? { lastRunSkipCount: cfg.lastRunSkipCount } : {}),
     consecutiveFailures: cfg.consecutiveFailures,
     elapsedMs,
     ...(cfg.lastRunHistoryId !== undefined ? { lastRunHistoryId: cfg.lastRunHistoryId } : {}),
@@ -2084,6 +2609,8 @@ export async function buildAutosyncStatusByChannel(dir: string): Promise<Record<
       ...(cfg.lastRunAt !== undefined ? { lastRunAt: cfg.lastRunAt } : {}),
       ...(cfg.lastRunStatus !== undefined ? { lastRunStatus: cfg.lastRunStatus } : {}),
       ...(cfg.lastRunMessage !== undefined ? { lastRunMessage: cfg.lastRunMessage } : {}),
+      ...(cfg.lastRunSkipReason !== undefined ? { lastRunSkipReason: cfg.lastRunSkipReason } : {}),
+      ...(cfg.lastRunSkipCount !== undefined ? { lastRunSkipCount: cfg.lastRunSkipCount } : {}),
       consecutiveFailures: cfg.consecutiveFailures,
       elapsedMs,
       ...(cfg.lastRunHistoryId !== undefined ? { lastRunHistoryId: cfg.lastRunHistoryId } : {}),
@@ -2102,6 +2629,10 @@ interface AutosyncStatusResponse {
   lastRunAt?: string
   lastRunStatus?: AutosyncRunStatus
   lastRunMessage?: string
+  /** issue #79：本轮跳过的**结构化原因码**（界面按码取字典；语言在渲染那一刻解析） */
+  lastRunSkipReason?: string
+  /** 跳过涉及的分区数（当前仅 conflict：远端另有 N 个分区待确认） */
+  lastRunSkipCount?: number
   consecutiveFailures: number
   elapsedMs: number
   lastRunHistoryId?: string
@@ -2111,7 +2642,7 @@ interface AutosyncStatusResponse {
 
 /** POST /restore 请求体校验（纯函数；snapshotId 拒绝路径分隔符防 join 越界）。 */
 export type BuildRestoreBodyResult =
-  | { ok: true; value: { snapshotId: string; dryRun: boolean } }
+  | { ok: true; value: { snapshotId: string; dryRun: boolean; planFingerprint?: string } }
   | { ok: false; error: string }
 
 export function buildRestoreBody(body: unknown): BuildRestoreBodyResult {
@@ -2126,7 +2657,16 @@ export function buildRestoreBody(body: unknown): BuildRestoreBodyResult {
   if (snapshotId === '.' || snapshotId === '..' || snapshotId.includes('/') || snapshotId.includes('\\')) {
     return { ok: false, error: zhMsg('restore.invalidSnapshotId') }
   }
-  return { ok: true, value: { snapshotId, dryRun: record['dryRun'] === true } }
+  // 预览-执行一致性（P3）：客户端把预览时拿到的计划指纹带回来；缺省 = 旧客户端，行为不变。
+  const planFingerprint = record['planFingerprint']
+  return {
+    ok: true,
+    value: {
+      snapshotId,
+      dryRun: record['dryRun'] === true,
+      ...(typeof planFingerprint === 'string' && planFingerprint !== '' ? { planFingerprint } : {}),
+    },
+  }
 }
 
 /* ------------------------------------------- snapshots/file-diff（git 风格预览） */
@@ -2218,7 +2758,7 @@ export async function executeRestorePlan(
         case 'hostFileRestore':
         case 'fileRestore': {
           if (action.target === undefined || action.blobPath === undefined) {
-            throw new Error('恢复动作缺少 target/blobPath')
+            throw new Error(engineMsg('restore.missingTargetBlob'))
           }
           if (await exec.existsHome(action.target)) await exec.savePreRestore(action.target)
           await exec.writeHome(action.target, await exec.readBlob(action.blobPath))
@@ -2227,7 +2767,7 @@ export async function executeRestorePlan(
         }
         case 'hostFileRemove':
         case 'fileRemove': {
-          if (action.target === undefined) throw new Error('恢复动作缺少 target')
+          if (action.target === undefined) throw new Error(engineMsg('restore.missingTarget'))
           if (await exec.existsHome(action.target)) {
             await exec.savePreRestore(action.target)
             await exec.removeHome(action.target)
@@ -2236,12 +2776,12 @@ export async function executeRestorePlan(
           break
         }
         case 'pluginRemove': {
-          if (action.pluginName === undefined) throw new Error('恢复动作缺少插件名')
+          if (action.pluginName === undefined) throw new Error(engineMsg('restore.missingPluginName'))
           const result = await exec.uninstallPlugin(action.pluginName)
           if (result.ok) {
             report.removedPlugins.push(action.pluginName)
           } else {
-            report.failed.push({ item: `plugin:${action.pluginName}`, reason: result.message ?? '卸载失败' })
+            report.failed.push({ item: `plugin:${action.pluginName}`, reason: result.message ?? engineMsg('restore.pluginRemoveFailed') })
           }
           break
         }
@@ -2252,7 +2792,7 @@ export async function executeRestorePlan(
           report.skipped.push(action.description)
           break
         default:
-          report.skipped.push(`未知动作 ${String(action.kind)}: ${action.description}`)
+          report.skipped.push(engineMsg('restore.unknownAction', { kind: String(action.kind), description: action.description }))
       }
     } catch (err) {
       report.failed.push({
@@ -2536,7 +3076,7 @@ function makeRoutes(deps: RoutesDeps): { routes: WebRoute[]; scheduler: AutoSync
         result: 'success',
         sections: [],
         source: 'api',
-        summary: `自动保留清理删除 ${removedIds.length} 个旧快照`,
+        summary: engineMsg('host.snapshotPruneSummary', { count: removedIds.length }),
       })
     } catch (error) {
       host.log.warn('快照保留清理历史写入失败（best-effort）', { error: error instanceof Error ? error.message : String(error) })
@@ -2601,7 +3141,7 @@ function makeRoutes(deps: RoutesDeps): { routes: WebRoute[]; scheduler: AutoSync
   /** 已知 adapter id 集合（push 请求体 sections 校验用）。 */
   const knownSyncSectionIds = new Set(adapters.map((a) => a.id))
   /** 可同步分区目录（status 回填 UI「同步分区」勾选列表）。
-   *  只含 portable + 显式可选项（OPT_IN_SYNC_SECTIONS，目前只有 sessions）——
+   *  只含 portable + 显式可选项（OPT_IN_SYNC_SECTIONS，当前 mcp / sessions）——
    *  后者是 deviceSpecific，UI 必须显示设备相关徽章，且只有用户主动勾选才进同步通道。 */
   const syncSectionCatalog = adapters
     .filter((a) => a.portability === 'portable' || OPT_IN_SYNC_SECTIONS.includes(a.id))
@@ -2622,6 +3162,8 @@ function makeRoutes(deps: RoutesDeps): { routes: WebRoute[]; scheduler: AutoSync
       retentionPolicy: () => retentionPolicyProvider(),
       // m-retention：分层选择器由宿主注入（core 不反向依赖 sync）
       pruneSelector: retentionPruneSelector,
+      // 保留清理被放弃/失败的唯一可见线索（core 不持 logger，由宿主接 host.log）
+      onWarn: (message) => { host.log.warn(message) },
     }),
     parseZipOverride: createHardenedZipParser(),
     dependencyChecker: dependencyAvailable,
@@ -2811,20 +3353,48 @@ function makeRoutes(deps: RoutesDeps): { routes: WebRoute[]; scheduler: AutoSync
     return out
   }
 
-  /** 该通道的持久化选择是否显式勾选了「可选分区」（sessions）—— 决定用户驱动的拉取侧能否看见它。 */
-  const selectionHasOptInSections = (channel: SyncTransportType): boolean => {
+  /**
+   * 该通道持久化选择里**显式勾选**的可选分区（与注册表白名单取交集；缺省 / 默认模式 → 空集）。
+   *
+   * onlyAuto=true 时只保留 'auto' 档（AUTO_SYNC_OPT_IN_SECTIONS）—— 自动同步调用点的口径：
+   * mcp 跟着走，sessions（'manual'）绝不悄悄下行/上行。
+   */
+  const selectionOptInSections = (channel: SyncTransportType, onlyAuto = false): SectionId[] => {
     const sel = selectionCache[channel]
-    if (sel === undefined) return false
+    if (sel === undefined) return []
     const sections = effectiveSections(sel)
-    return sections !== undefined && sections.some((id) => OPT_IN_SYNC_SECTIONS.includes(id))
+    if (sections === undefined) return []
+    const allowed = onlyAuto ? AUTO_SYNC_OPT_IN_SECTIONS : OPT_IN_SYNC_SECTIONS
+    return sections.filter((id) => allowed.includes(id))
   }
 
   /** 构造 SyncEngine：按 transport 分支构造对应传输（git → GitTransport；webdav → WebDavTransport）。
    *  同步范围（sections）来自持久化分区选择：advanced 模式 → 只处理勾选分区，
    *  自动同步（merge/apply/push 全链路）与手动 push 共用此配置。
-   *  opts.includeOptInSections：仅**用户驱动**的拉取/一键同步路由传 true（用户的选择里
-   *  确实勾了 sessions 时）—— 自动同步调用点一律不传，会话分区绝不悄悄下行。 */
-  const makeSyncEngine = (cfg: SyncConfig, engineOpts: { includeOptInSections?: boolean } = {}): SyncEngine => {
+   *  opts.optInSections：本次显式放行的可选分区集合 —— 用户驱动的手动 push/pull 传
+   *  「选择里勾的全部可选分区」，自动同步只传 'auto' 档（sessions 绝不悄悄下行/上行）。 */
+  /**
+   * git 通道的工作副本根（`<dataDir>/sync/work`）——**唯一**决定路径的地方：
+   * 同步引擎与「工作副本自检/重建」（issue #79）必须指向同一个目录，否则用户重建了 A 而同步在跑 B。
+   */
+  const gitWorkDir = join(syncDir, 'work')
+  /**
+   * 构造 git 通道实例（同步引擎与 issue #79 的工作副本自检/重建共用同一份地址与凭据口径）。
+   * token 只经 credentials 端口现取（值永不落盘/日志/回传）。
+   */
+  const makeGitTransport = (repoUrl: string): GitTransport => new GitTransport({
+    repoUrl,
+    workDir: gitWorkDir,
+    credentials: {
+      getToken: async () => {
+        const resolved = await credentials.resolve(credentialRef(SYNC_CREDENTIAL_REF))
+        return resolved?.value ?? ''
+      },
+    },
+    msg,
+  })
+
+  const makeSyncEngine = (cfg: SyncConfig, engineOpts: { optInSections?: readonly SectionId[] } = {}): SyncEngine => {
     let transport: SyncTransport
     if (isWebDavConfig(cfg)) {
       transport = new WebDavTransport({
@@ -2876,17 +3446,7 @@ function makeRoutes(deps: RoutesDeps): { routes: WebRoute[]; scheduler: AutoSync
         msg,
       })
     } else {
-      transport = new GitTransport({
-        repoUrl: cfg.git.repoUrl,
-        workDir: join(syncDir, 'work'),
-        credentials: {
-          getToken: async () => {
-            const resolved = await credentials.resolve(credentialRef(SYNC_CREDENTIAL_REF))
-            return resolved?.value ?? ''
-          },
-        },
-        msg,
-      })
+      transport = makeGitTransport(cfg.git.repoUrl)
     }
     const channel: SyncTransportType = channelOf(cfg)
     const sections = effectiveSections(selectionCache[channel] ?? defaultSyncSelection())
@@ -2900,7 +3460,9 @@ function makeRoutes(deps: RoutesDeps): { routes: WebRoute[]; scheduler: AutoSync
       zipDir: tmpDir,
       msg,
       ...(sections === undefined ? {} : { sections }),
-      ...(engineOpts.includeOptInSections === true ? { includeOptInSections: true } : {}),
+      ...(engineOpts.optInSections === undefined || engineOpts.optInSections.length === 0
+        ? {}
+        : { optInSections: engineOpts.optInSections }),
       // m-retention：远端快照裁剪与本地备份产物共用同一份 GFS 保留策略（缺省 = 最近 10 个，
       // 与改造前逐字等价）；用户改完策略即时生效（每次 prune 都重读）。
       retentionPolicy: () => retentionPolicyProvider(),
@@ -2914,7 +3476,9 @@ function makeRoutes(deps: RoutesDeps): { routes: WebRoute[]; scheduler: AutoSync
   const scheduler = new AutoSyncScheduler({
     syncDir,
     host,
-    makeSyncEngine,
+    // 自动同步只放行 'auto' 档可选分区（当前 = mcp）：sessions（'manual'）绝不悄悄下行/上行。
+    // 口径钉在**注入处**而不是调度器内部 —— 调度器只负责「用哪个引擎」，准入由宿主决定。
+    makeSyncEngine: (cfg: SyncConfig) => makeSyncEngine(cfg, { optInSections: selectionOptInSections(channelOf(cfg), true) }),
     msg,
     runs,
     mutationLock: host.mutationLock,
@@ -2928,7 +3492,10 @@ function makeRoutes(deps: RoutesDeps): { routes: WebRoute[]; scheduler: AutoSync
         result: entry.status === 'success' ? 'success' : entry.status === 'skipped' ? 'skipped' : 'failed',
         sections: entry.appliedSections ?? [],
         source: 'autosync',
-        summary: `自动同步 ${entry.direction}${entry.transport !== undefined ? `（${entry.transport}）` : ''}`,
+        summary: engineMsg('host.autosyncSummary', {
+          direction: entry.direction,
+          transportSuffix: entry.transport !== undefined ? engineMsg('host.autosyncTransportSuffix', { transport: entry.transport }) : '',
+        }),
         error: entry.status === 'failed' ? (entry.error ?? entry.skipReason) : undefined,
       }).catch(() => undefined)
     },
@@ -3179,6 +3746,11 @@ function makeRoutes(deps: RoutesDeps): { routes: WebRoute[]; scheduler: AutoSync
         targetFormatVersion: () => host.sessionFormatVersion,
         workspaceKeys: async () => await sessionHealthWorkspaceKeys(host),
         knownSessionIds: async () => await sessionHealthKnownIds(host),
+        // T4+：体检行要显示**对话标题**（此前只有 `session-<uuid>` 目录名，认不出哪条是自己的对话）。
+        // 标题住在 DSH 自己的会话缓存里，读取口径与导出选择器**同一份实现**（core/session-meta.ts：
+        // 只读、mtime 失效缓存、读不到退化成空索引）。这里只把索引交给路由 —— 路由不自己读盘。
+        // ids = 本次要展示的会话（单元 id / 目录名都行）：只给这些补标题，逐会话投影文件按需读（不再只吃聚合缓存）
+        sessionMeta: async (ids: readonly string[]) => await readSessionMetaWithTitles(host, ids),
       },
       pruneStagedMarketZips,
       readCachedIndexObj,
@@ -3192,13 +3764,32 @@ function makeRoutes(deps: RoutesDeps): { routes: WebRoute[]; scheduler: AutoSync
       runs,
       scheduler,
       selectionCache,
-      selectionHasOptInSections,
+      selectionOptInSections,
       selectionView,
       selectionViewByChannel,
       snapshotEntrySections,
       snapshotsDir,
       syncCredentialsByChannelView,
       syncDir,
+      // issue #79：工作副本自检（只读，挂在 /sync/status）与显式重建（写动作，走 mutation gate）。
+      // 路由只传 repoUrl/mode —— 路径、凭据与 git 调用口径都留在宿主这一处。
+      syncWorkDir: {
+        // 自检失败（git 不可用 / 工作副本异常）→ 返回 { error }，**不让整个状态接口 500**，
+        // 也不伪装成「工作副本不存在」。
+        inspect: async (repoUrl: string): Promise<{ facts: GitWorkDirFacts } | { error: string }> => {
+          try {
+            return { facts: await makeGitTransport(repoUrl).inspectWorkDir() }
+          } catch (err) {
+            return { error: err instanceof Error ? err.message : String(err) }
+          }
+        },
+        // 重建：relink 非破坏；reclone 删目录重克隆（调用方必须先取得用户确认）
+        rebuild: async (repoUrl: string, mode: 'relink' | 'reclone'): Promise<GitWorkDirFacts> => {
+          const transport = makeGitTransport(repoUrl)
+          await transport.rebuildWorkDir(mode)
+          return await transport.inspectWorkDir()
+        },
+      },
       syncPasswordConfigured,
       syncSectionCatalog,
       // 关于页「立即更新」：用户显式点击后的写动作（官方 dsh plugin 通道，钉住精确版本）。
@@ -3226,7 +3817,7 @@ function makeRoutes(deps: RoutesDeps): { routes: WebRoute[]; scheduler: AutoSync
   /**
    * 路由表：本文件只保留被源码级守卫按**文件窗口**钉住的 7 条（host-entry 审计 F-04 记录的
    * tests/host/**、src/core/model-tools.test.ts、src/core/phase1-wiring.test.ts 的窗口断言）。
-   * 其余 71 条已按域拆到 src/routes/*.ts，由 buildRoutes 组装。
+   * 其余 72 条已按域拆到 src/routes/*.ts，由 buildRoutes 组装。
    * 注册顺序不影响匹配：命名路由必须互不相同（webServer 契约）。
    */
   const routeEnv: RouteEnvInferred = makeRouteEnv()
@@ -3316,10 +3907,11 @@ function makeRoutes(deps: RoutesDeps): { routes: WebRoute[]; scheduler: AutoSync
           return
         }
         const runId = run.runId
+        // 临时明文 ZIP 的路径必须在 try **之外**声明：失败分支也要能清理（见 finally）。
+        const plainZipPath = join(tmpDir, `export-plain-${randomBytes(4).toString('hex')}.zip`)
         try {
           // 先由 Exporter 产出标准明文 ZIP（含 manifest/checksums；若 includeSecrets 需要
           // 加密提供者来生成 secrets.enc —— 整体容器的外层加密再保护整个文件）。core 不感知外层容器。
-          const plainZipPath = join(tmpDir, `export-plain-${randomBytes(4).toString('hex')}.zip`)
           const exporter = new Exporter({
             ctx: host,
             adapters,
@@ -3361,9 +3953,9 @@ function makeRoutes(deps: RoutesDeps): { routes: WebRoute[]; scheduler: AutoSync
           if (password !== undefined) {
             const plainZip = await fs.readFile(plainZipPath)
             const { blob } = await encryptArchive(plainZip, password)
-            await fs.writeFile(outPath, blob)
-            // 临时明文 ZIP 立即清理，磁盘不残留明文备份
-            await fs.rm(plainZipPath, { force: true }).catch(() => undefined)
+            // 原子落盘：直接 writeFile 中途失败会留下一个**名字正常**的半截 .zip（会出现在产物库里）。
+            // 临时明文 ZIP 的清理统一由 finally 负责（成功 / 失败都清）。
+            await atomicWriteFile(outPath, blob)
           } else {
             await fs.rename(plainZipPath, outPath)
           }
@@ -3385,6 +3977,11 @@ function makeRoutes(deps: RoutesDeps): { routes: WebRoute[]; scheduler: AutoSync
           runs.fail(runId, message)
           host.log.error('导出失败', { error: message })
           writeJson(res, 500, { error: message, runId })
+        } finally {
+          // 明文临时 ZIP 必须在这里清：失败分支（加密失败 / 磁盘满 / 超时）此前**不清理**，
+          // 含全部非敏感配置的明文会留在 <dataDir>/tmp 直到 24h 缓存清理 —— 与「磁盘不残留明文备份」
+          // 的承诺不符。成功路径已 rename 或已原子写入，这里对不存在的路径是 no-op（force: true）。
+          await fs.rm(plainZipPath, { force: true }).catch(() => undefined)
         }
     }),
     // ---------------------------------------------------- export-preview
@@ -3466,7 +4063,14 @@ function makeRoutes(deps: RoutesDeps): { routes: WebRoute[]; scheduler: AutoSync
           const sessionsEntry = preview.find((p) => p.section === 'sessions')
           if (sessionsEntry !== undefined && sessionsEntry.items.length > 0) {
             try {
-              sessionsEntry.items = applySessionMeta(sessionsEntry.items, await readSessionMeta(host), 'sessions', sessionActivityTimes)
+              // 标题要**尽量全**（用户 2026-10-12：始终用对话标题，而不是只取聚合缓存里的）：
+              // 聚合缓存缺的那些按需读逐会话投影文件（只读、定向、mtime 缓存）
+              sessionsEntry.items = applySessionMeta(
+                sessionsEntry.items,
+                await readSessionMetaWithTitles(host, sessionsEntry.items.map((u) => u.id)),
+                'sessions',
+                sessionActivityTimes,
+              )
             } catch {
               /* 保持目录名（旧行为） */
             }
@@ -3582,7 +4186,10 @@ function makeRoutes(deps: RoutesDeps): { routes: WebRoute[]; scheduler: AutoSync
           // 只在计划真的含该分区时才读 storages；读不到就保持目录名，绝不让计划生成失败。
           if (plan.items.some((i) => i.adapter === 'sessions')) {
             try {
-              plan.items = applySessionMetaToPlanItems(plan.items, await readSessionMeta(host))
+              plan.items = applySessionMetaToPlanItems(
+                plan.items,
+                await readSessionMetaWithTitles(host, plan.items.filter((item) => item.adapter === 'sessions').map((item) => item.unitId ?? item.id)),
+              )
             } catch {
               /* 保持目录名（旧行为） */
             }
@@ -3806,7 +4413,19 @@ export function apply(ctx: Context, config?: Config): void {
       })
       const { state } = await startupState.classify()
       startupStateResolved = true
-      phase3Recovery.safeModeActive = phase3Recovery.safeModeActive || ['RECOVERY_REQUIRED', 'NEEDS_ATTENTION', 'UNKNOWN_STATE'].includes(state.kind)
+      // issue #87：分类结论才是本轮权威。NORMAL 且没有活锁者 ⇒ 上一轮留下的 durable SAFE MODE 是**陈旧标记**
+      // （没有任何未决 journal 能解释它），必须连内存标志一起复位：只复位内存会让本会话写操作继续被 423 挡着
+      // （界面却说「无待处理事项」），只复位标记又会在下一次 probe 时重新置起（标记跨重启生效）。
+      const safeModeVerdict = resolveStartupSafeMode({
+        kind: state.kind,
+        lockState: mapLockStateForStartup(lockInsp.state),
+        currentlyBlocked: phase3Recovery.safeModeActive,
+      })
+      phase3Recovery.safeModeActive = safeModeVerdict.blocked
+      if (safeModeVerdict.clearStaleMarker) {
+        await phase3Recovery.clearSafeMode().catch(() => undefined)
+        host.log.info('Phase 3 启动分类 NORMAL：上一轮遗留的 SAFE MODE 标记已复位（无未决事务、无活锁者）')
+      }
       shouldStartSchedulers = (state.kind === 'NORMAL')
       if (state.kind === 'RECOVERY_REQUIRED' || state.kind === 'NEEDS_ATTENTION') {
         host.log.warn(`Phase 3 ${state.kind}：上次 destructive operation 崩溃残留，需显式恢复；destructive 调度器未启动（read-only host 存活）`)
@@ -3990,6 +4609,143 @@ export function apply(ctx: Context, config?: Config): void {
       profileRuntime.withdraw()
     }
   }, 'config-manager: profile runtime heartbeat')
+  // ------------------------------------------- S1：回合自动留点（宿主真接线）
+  //
+  // 订阅 `session/event`（@deepseek-ai/dsh-session 的 post-commit fire-and-forget feed），
+  // 每见到一个 `turn/end` 就为**当前会话**留一个回滚点 = 工作区快照（内容寻址入对象仓）
+  // + 会话游标（事件数 / fork 边界）。没有手动「拍点」入口 —— 留点完全由回合驱动。
+  //
+  // 纪律（AGENTS.md 铁律 + captain 要求）：**订阅与每个回调都 try/catch 包裹**，任何异常
+  // 只记 warn：改坏宿主启动 = blocker。事件回调用一条串行链喂给留点器，保证同一会话的
+  // turn/start 与 turn/end **按到达顺序**处理（留点本身是异步 IO）。
+  // fork 端口用**结构性窄化**读取：`SessionStoreFacade`（src/core/types.ts）不在本任务 scope 内，
+  // 不为了这一处调用去改公共接口；端口上确实有 forkSession（DshSessionStoreFacade 实现）才走
+  // 真 fork，否则如实结构化 `session-fork-unavailable`（绝不静默降级）。
+  const forkPort = host.sessions as unknown as RollbackForkCarrier
+  const rollbackEngine = new RollbackPointEngine({
+    dataDir,
+    homeDir,
+    log: (line) => host.log.warn(line),
+    fork: async ({ sessionId, boundarySeq }) => {
+      const forkSession = forkPort.forkSession
+      if (typeof forkSession !== 'function') {
+        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) {
+        // warning 一路带到回退结果（引擎落成 rollback.guidance.sessionNotAttached）：
+        // 归位失败**不静默** —— 会话确实回退了，但它会出现在侧栏「未分组」。
+        return result.warning !== undefined
+          ? { ok: true as const, childSessionId: result.childSessionId, warning: result.warning }
+          : { ok: true as const, childSessionId: result.childSessionId }
+      }
+      return { ok: false as const, code: 'fork-failed' as const, detail: result.error }
+    },
+  })
+  const rollbackTracker = new RollbackAutoTracker({ engine: rollbackEngine, log: (line) => host.log.warn(line) })
+  ctx.effect(() => {
+    let chain: Promise<unknown> = Promise.resolve()
+    // 「会话没有 cwd」这类**形状合法但信息不全**的情况只记一次日志（避免每回合刷屏）；
+    // 该点本身仍带 incomplete=true + workspace.reasonCode='no-chunks'，界面能如实展示。
+    const chunklessLogged = new Set<string>()
+    const listener = (session: unknown, event: unknown): void => {
+      try {
+        const bindingResult = rollbackSessionBindingOf(session)
+        if (!bindingResult.ok) {
+          // 形状不匹配**不静默**：给显式机器码，宿主日志留痕
+          host.log.warn('rollback auto point skipped: ' + bindingResult.code + ' ' + bindingResult.detail)
+          return
+        }
+        const binding = bindingResult.binding
+        if (bindingResult.chunkless !== null && !chunklessLogged.has(binding.sessionId)) {
+          chunklessLogged.add(binding.sessionId)
+          host.log.warn('rollback auto point: session ' + binding.sessionId + ' ' + bindingResult.chunkless + ' → 该点只留会话态（incomplete）')
+        }
+        const eventResult = rollbackTrackedEventOf(binding.sessionId, event)
+        if (!eventResult.ok) {
+          host.log.warn('rollback auto point skipped: ' + eventResult.code + ' ' + eventResult.detail)
+          return
+        }
+        rollbackTracker.registerSession(binding)
+        const tracked = eventResult.event
+        chain = chain.then(async () => { await rollbackTracker.noteEvent(tracked) }).catch((error: unknown) => {
+          host.log.warn('rollback auto point failed: ' + (error instanceof Error ? error.message : String(error)))
+        })
+      } catch (error) {
+        host.log.warn('rollback auto point listener failed: ' + (error instanceof Error ? error.message : String(error)))
+      }
+    }
+    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)))
+    }
+    return () => {
+      try { off?.() } catch { /* 解绑失败不影响卸载 */ }
+      rollbackTracker.stop()
+    }
+  }, 'config-manager: rollback auto points')
+  // ------------------------------------------- 宿主斜杠命令 /rollback（t3）
+  //
+  // 与 HTTP 路由 /recovery/rollback-points/<id>/rewind **同源的那道写入门**：
+  //   runWithMutationLock（= SAFE MODE 门 + 跨进程/跨 kind 环境锁）→ 引擎 preview（零写入）→ 引擎 rewind。
+  // 顺序与路由**逐条一致**（预检在锁内、一切拒绝都发生在写入之前）；引擎回 confirmation-required /
+  // protected-point / record-incomplete 时命令只回可读错误结果，**绝不绕过**（preview 已把
+  // protected / incomplete 提前拦下，这里再挡一次 API 误用）。
+  //
+  // 命令服务**惰取**（调用期 ctx.get('commands')，绝不属性访问、绝不进 inject）+ 注册失败只 warn：
+  // 未组合 commands 的部署照常启动。注册点在 webServer 早退**之前** —— 没有 web 端的部署一样能用 /rollback。
+  const commandHost: RollbackCommandHost = {
+    // 会话事实只服务于「列出本会话的点」：回退的写入面由回退点自己的记录决定，不在这里临时指定。
+    agentSession: agentSessionFactsOf,
+    // 只读列表：引擎的 RollbackListResult 天然满足命令层的子集形状（storage/points/error）。
+    list: (sessionId) => rollbackEngine.list(),
+    rewind: async ({ id }) => {
+      // 与路由同一 op 名（审计/锁归属可对照）；target = 目标点 id。
+      // ⚠️ 这道门必须与 HTTP 路由同源：runWithMutationLock(host.mutationLock, {op:'rollback-rewind'}, …)。
+      // 绕过它 = 绕过 SAFE MODE 与环境锁（本文件的 route-fence/parity 守卫之外没有第二道兜底）。
+      return await runWithMutationLock(
+        host.mutationLock,
+        { op: 'rollback-rewind', target: id, isBlocked: () => host.safeModeIsBlocked?.() ?? false },
+        async () => {
+          // ① 预检（零写入）：先拦住 protected / incomplete / 存储缺失，再动任何字节。
+          const preview = await rollbackEngine.preview(id)
+          if (!preview.ok || !preview.canRestore) {
+            return {
+              ok: false,
+              outcome: 'denied',
+              code: preview.code,
+              id,
+              ...(preview.detail !== undefined ? { detail: preview.detail } : {}),
+              segments: [],
+              skippedSegments: [],
+              storage: preview.storage,
+              guidance: preview.guidance,
+              warnings: preview.warnings,
+            } satisfies RollbackRewindResult
+          }
+          // ② 真执行：userConfirmed **恒 true** —— 用户敲下 /rollback <id> 就是那次确认
+          //    （命令入口没有第二个确认按钮；其余门全量生效）。
+          return await rollbackEngine.rewind({
+            id,
+            userConfirmed: true,
+            removeCreated: true,
+          })
+        },
+      )
+    },
+  }
+  try {
+    const disposeRollbackCommand = registerRollbackCommand({
+      readCommands: () => readService<CommandServiceLike>(ctx, 'commands'),
+      deps: { host: commandHost, mutationLock: host.mutationLock, isBlocked: () => host.safeModeIsBlocked?.() ?? false },
+      log: host.log,
+    })
+    ctx.effect(() => () => disposeRollbackCommand(), 'config-manager: /rollback command')
+  } catch (error) {
+    host.log.warn('register /rollback failed: ' + (error instanceof Error ? error.message : String(error)))
+  }
   const webServer = readService<WebServer>(ctx, 'webServer')
   if (webServer === undefined) {
     host.log.warn('webServer 服务不可用：跳过 /api/dsh-config-manager 路由注册（引擎能力仍可用）')